Erstellen Sie dynamisch ein Array von Zeichenfolgen mit malloc

Lesezeit: 3 Minuten

Ich versuche, ein Array von Strings in C zu erstellen malloc. Die Anzahl der Zeichenfolgen, die das Array enthalten wird, kann sich zur Laufzeit ändern, aber die Länge der Zeichenfolgen bleibt immer konsistent.

Ich habe dies versucht (siehe unten), aber ich habe Probleme, alle Tipps in die richtige Richtung werden sehr geschätzt!

#define ID_LEN 5
char *orderedIds;
int i;
int variableNumberOfElements = 5; /* Hard coded here */

orderedIds = malloc(variableNumberOfElements * (ID_LEN + 1));

Letztendlich möchte ich das Array verwenden können, um dies zu tun:

strcpy(orderedIds[0], string1);
strcpy(orderedIds[1], string2);
/* etc */

  • Beachten Sie, dass Sie nicht verwenden sollten intist hier. a) Es ist signiert (und ich bezweifle, dass Sie eine Zeichenfolge mit der Länge -5 wollen), und b) es ist nicht garantiert, dass es die richtige Größe hat, um die Werte zu enthalten, die Sie benötigen. Verwenden Sie die size_t Typ zum Speichern von Array-Indizes und Objektgrößen. Das ist die Art des Arguments malloc.

    – Chris Lutz

    9. Mai 2011 um 11:16 Uhr

  • @Chris: Das heißt, es ist garantiert groß genug für 5.

    – Steve Jessop

    9. Mai 2011 um 11:37 Uhr

Benutzeravatar von MByD
MByD

Sie sollten ein Array von char-Zeigern zuweisen und dann jedem Zeiger genügend Speicher für die Zeichenfolge zuweisen:

char **orderedIds;

orderedIds = malloc(variableNumberOfElements * sizeof(char*));
for (int i = 0; i < variableNumberOfElements; i++)
    orderedIds[i] = malloc((ID_LEN+1) * sizeof(char)); // yeah, I know sizeof(char) is 1, but to make it clear...

Scheint mir ein guter Weg zu sein. Obwohl Sie viele Mallocs ausführen, weisen Sie eindeutig Speicher für eine bestimmte Zeichenfolge zu, und Sie können einen Speicherblock freigeben, ohne das gesamte “String-Array” freizugeben.

  • Müssen Sie eine weitere for-Schleife verwenden, um den zugewiesenen Speicher freizugeben?

    – Minh Tran

    14. September 2015 um 2:30 Uhr

  • Ja, die Verwendung von Schleifen zur mehrmaligen Ausführung derselben Operation ist eine gute und gängige Praxis, die zu einer Notwendigkeit wird, wenn sie eine variable Anzahl von Malen ausgeführt wird. (Aber jede for-Schleife kann auch als while-Schleife implementiert werden.)

    – MByD

    14. September 2015 um 21:14 Uhr

char **orderIds;

orderIds = malloc(variableNumberOfElements * sizeof(char*));

for(int i = 0; i < variableNumberOfElements; i++) {
  orderIds[i] = malloc((ID_LEN + 1) * sizeof(char));
  strcpy(orderIds[i], your_string[i]);
}

Benutzeravatar von Oliver Charlesworth
Oliver Charlesworth

Da Ihre Zeichenfolgen alle eine feste Länge haben (vermutlich zur Kompilierzeit?), Können Sie Folgendes tun:

char (*orderedIds)[ID_LEN+1]
    = malloc(variableNumberOfElements * sizeof(*orderedIds));

// Clear-up
free(orderedIds);

Eine umständlichere, aber allgemeinere Lösung besteht darin, ein Array von Zeigern zuzuweisen und sie so zu initialisieren, dass sie auf Elemente eines rohen Hintergrundarrays zeigen:

char *raw = malloc(variableNumberOfElements * (ID_LEN + 1));
char **orderedIds = malloc(sizeof(*orderedIds) * variableNumberOfElements);

// Set each pointer to the start of its corresponding section of the raw buffer.
for (i = 0; i < variableNumberOfElements; i++)
{
    orderedIds[i] = &raw[i * (ID_LEN+1)];
}

...

// Clear-up pointer array
free(orderedIds);
// Clear-up raw array
free(raw);

  • Warum würdest du alles zuordnen orderedIds[0]?

    – MByD

    9. Mai 2011 um 11:06 Uhr

  • @Chris: Ja, in der Tat. Tatsächlich habe ich gerade diese Änderung vorgenommen!

    – Oliver Charlesworth

    9. Mai 2011 um 11:08 Uhr

  • @Oli – Das habe ich gesehen. Vielleicht möchten Sie eine Anmerkung hinzufügen, wie man diesen ersten richtig befreien würde, da es ziemlich unintuitiv ist.

    – Chris Lutz

    9. Mai 2011 um 11:10 Uhr

  • Was gibt der “malloc”-Aufruf der ersten Option zurück? Welche Art von Zeiger? Wenn ich versuche, es als irgendetwas (char*, char**…) umzuwandeln, erhalte ich Fehler

    – Dori

    4. Juni 2013 um 6:58 Uhr

Benutzeravatar von Roman
römisch


#define ID_LEN 5
char **orderedIds;
int i;
int variableNumberOfElements = 5; /* Hard coded here */

orderedIds = (char **)malloc(variableNumberOfElements * (ID_LEN + 1) * sizeof(char));

..

1411950cookie-checkErstellen Sie dynamisch ein Array von Zeichenfolgen mit malloc

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy