Mit strncpy() kopieren const char *

Ich bin sehr neu in C, ich bin stecken mit der strncpy-Funktion.\

Hier ist ein Beispiel was, mit dem ich arbeite:

int main()
{

const char *s = "how";

struct test {
    char *name;
};

struct test *t1 = malloc(sizeof(struct test));

strncpy(t1->name, s, sizeof(*s));
t1->name[NAMESIZE] = '\0';

printf("%s\n", t1->name);

}

Ich habe ein const char *, ich brauche, um die "name" - Wert test, um den const char. Ich habe eine wirklich harte Zeit, herauszufinden dieses heraus. Ist das überhaupt der richtige Ansatz?

Vielen Dank!

  • Wo soll man beginnen...
  • Sehr gut gesagt 😀
InformationsquelleAutor isal | 2013-02-09
  1. 5

    Gut, Sie ordnen die Struktur, nicht aber die Zeichenfolge innen der Struktur. Sie müssen das tun, bevor Sie kopieren, um es. Auch wenn Sie tun, werden Sie wahrscheinlich überschreiben nicht zugewiesenen Arbeitsspeicher, wenn Sie versuchen, die string-terminator.

    Und durch eine hohe Zufuhr ow Wein, ich habe gerade bemerkt, dass Sie eigentlich nur kopieren ein Zeichen, aber es ist immer noch Undefiniertes Verhalten.

    • Danke. Ich zugeordnet t1->name = malloc(sizeof(s)), und dann verwendet, strncpy. Es funktioniert jetzt, aber es sagt, dass strncpy ist eine Funktion auf char, aber ich bin mit dem sizeof char *.
    • 4 oder 8 bytes, abhängig davon, ob man auf einem 32-oder 64-bit-Plattform. sizeof(*s) 1 ist, so ist es das gleiche wie sizeof(char) die angegeben ist in der C-Spezifikation gleich eins ist. Sie sollten wahrscheinlich verwenden Sie strlen(s) + 1.
    • Ahh, danke. Das macht Sinn.
    • Ihr Wein scheint, du hast mehr rep als mein whisky. Ist dies die wirkliche Lektion hier? :-S
    • Diese Antwort verwirrt mich ein wenig, also ich bin der Klärung für andere Leser. malloc(sizeof(struct test)) ordnet die Struktur, einschließlich der char* drin, aber es hat nicht den Speicher, wo der char* wird sich zeigen. Wenn Sie möchten, verwenden Sie die Zeichenfolge selbst (im Gegensatz zu den Zeiger darauf), die Sie benötigen, um alloc neuen Speicher.
    • Und ich weiß, diese Frage ist alt, aber wie sieht strncpy(t1->name, s, sizeof(*s)); nur kopieren ein Zeichen?
    • ist ein Zeiger auf char, dereferenzieren s (was *s tut), gibt Sie einen einzelnen char, und die Größe einer einzelnen char ist immer 1.
    • Also, wie würden Sie die Größe des ganzen string? strlen(s)*sizeof(char)?
    • Nur strlen ist genug, es gibt Sie die Anzahl der Zeichen in der Zeichenfolge. sizeof(har) definiert wird, in der C-Spezifikation zurück 1 immer.

    InformationsquelleAutor Some programmer dude
  2. 3

    Nehmen wir diesen einen Schritt zu einem Zeitpunkt:

    struct test *t1 = malloc(sizeof(struct test));

    diese reserviert Speicherplatz für einen struct test; genug Platz für die Zeiger name, aber nicht alle Speicher für den pointer zu Punkt zu. Zumindest, werden Sie wollen, um Folgendes zu tun:

    t1->name = malloc(strlen(s) + 1);

    Wenn dies erledigt ist, können Sie fortfahren, um kopieren Sie die Zeichenfolge. Jedoch, Sie bereits berechnete die Länge der Schnur einmal um den Speicher, es gibt keinen Sinn, es zu tun, wieder implizit durch den Aufruf strncpy. Führen Sie stattdessen folgende Schritte:

    const size_t len = strlen(s) + 1;  //+1 accounts for terminating NUL
t1->name = malloc(len);
memcpy(t1->name, s, len);

    In der Regel versuchen, verwenden Sie dieses basic pattern; berechnen Sie die Länge der Zeichenfolgen einmal, wenn Sie kommen in Ihre code -, aber dann verwenden Sie die explizite dimensionierten Pufferspeicher und die mem* Operationen statt implizite-Länge-Zeichenfolgen mit str* Operationen. Es ist mindestens so sicher (und oft auch sicherer) und effizienter, wenn es richtig gemacht.

    Könnten Sie strncpy wenn t1->name wurde ein array fester Größe statt (obwohl viele Menschen es vorziehen, zu verwenden strlcpy). Das würde wie folgt Aussehen:

    struct test { char name[MAXSIZE]; };
struct test *t1 = malloc(sizeof *t1);
strncpy(t1->name, s, MAXSIZE - 1);
t1->name[MAXSIZE-1] = 0; //force NUL-termination

    Beachten Sie, dass die size argument strncpy sollte immer der Größe der Ziel, nicht die Quelle, zu vermeiden, schreiben die außerhalb der Grenzen des Ziel-Puffer.

    • Vielen Dank für die ausführliche Erklärung, ist es viel übersichtlicher jetzt.
    • Könnte man die MAXSIZE - 1 im strncpy "Optimierung jenseits aller Vernunft"? 🙂
    InformationsquelleAutor Stephen Canon
  3. 2

    Ohne jeden Versuch, die Vollständigkeit oder die pädagogische Leitung, hier ist eine version des Codes, die funktionieren sollte. Sie können das Spiel "finde den Unterschied" und Suche nach einer Erklärung für jedes separat auf dieser Website.

    int main()
{ 
    const char s[] = "how";                 //s is an array, const char[4]

    struct test{ char name[NAMESIZE]; };    //test::name is an array

    struct test * t1 = malloc(sizeof *t1);  //DRY

    strncpy(t1->name, s, NAMESIZE);         //size of the destination
    t1->name[NAMESIZE - 1] = '\0';          //because strncpy is evil

    printf("%s\n", t1->name);

    free(t1);                               //clean up
}
    • Ich bin nicht die Freiheit der Veränderung der struct-definition. Aber ich merke mein Fehler, wo ich dabei war malloc(sizeof struct test) und nicht sizeof *t1. Danke
    • Dann nur nicht vergessen, um den Speicher für den string als gut, und verwenden Sie strlen, um die Berechnung der Größe eines solchen strings.
    • Wenn Sie behandeln müssen test::name dynamisch, siehe Stephen ' s beantworten, aber vergessen Sie nicht, sauber, getrennt.
    InformationsquelleAutor Kerrek SB
  4. 1

    strncpy() ist immer falsch

    • wenn das Ergebnis zu lang ist, wird der Ziel-string nicht null-terminiert
    • wenn das Ziel ist zu lang (das Dritte argument) , wird der trailing-Ende werden komplett gepolstert mit NULs. Diese verschwenden eine Menge von Zyklen, wenn Sie große Puffer und kurze Zeichenfolgen.

    Statt, Sie kann verwenden, memcpy() oder strcpy (oder in deinem Fall sogar strdup() )

    int main()
{
const char *s = "how";

struct test {
    char *name;
    };
struct test *t1
size_t len;

t1 = malloc(sizeof *t1);

#if USE_STRDUP

  t1->name = strdup(s);

#else

  len = strlen(s);
  t1->name = malloc (1+len);
  memcpy(t1->name, s, len);
  t1->name[len] = '\0';

#endif    

printf("%s\n", t1->name);

return 0;
}
    • Sollte das relativiert werden: "strncpy ist immer falsch für dynamisch zugewiesenen Ziele"?
    • Nein. Es ist immer falsch. Da Sie manuell reparieren der Ecke Fall, Sie könnte genauso gut verwenden memcpy in den ersten Platz.
    • Hmm. Angenommen, Sie sind immer kopieren in ein kleiner Puffer. Verwenden memcpy müsstest du erstmal das über die ganze Länge der (möglichst großen) string. Mit strncpy zahlen Sie eventuell ein paar zusätzliche unnötige Nullen, aber nie mehr als die (kurze) Ziel Länge.
    • FWIW snprintf(dest, dest_size, "%s", src); ist ein standard und macht-was-Sie-erwarten-Ersatz für strncpy.
    InformationsquelleAutor wildplasser
Schreibe einen Kommentar