Créer dynamiquement un tableau de chaînes de caractères avec la fonction malloc

Je suis en train de créer un tableau de chaînes de caractères en C, en utilisant malloc. Le nombre de chaînes que le tableau tiendra peut changer au moment de l'exécution, mais la longueur des chaînes sera toujours cohérents.

J'ai tenté ce (voir ci-dessous), mais éprouve de la difficulté, des astuces dans la bonne direction sera très appréciée!

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

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

En fin de compte, je veux être en mesure d'utiliser le tableau pour ce faire:

strcpy(orderedIds[0], string1);
strcpy(orderedIds[1], string2);
/* etc */
  • Notez que vous ne devriez pas être à l'aide de ints ici. a) Il est signé (et je doute que vous voulez de -5 longueur de la chaîne), et b) il n'est pas garanti d'être à la bonne taille pour tenir les valeurs dont vous avez besoin pour tenir. Utiliser le size_t type pour le stockage des index de tableau d'objet et de tailles. C'est le type de l'argument de malloc.
  • cela dit, c'est la garantie d'être assez grand pour 5.
InformationsquelleAutor Chris | 2011-05-09
  1. 52

    Vous devez affecter un tableau de pointeurs de char, et ensuite, pour chaque pointeur affecter suffisamment de mémoire pour la chaîne:

    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...

    Semble être une bonne façon pour moi. Même si vous effectuez de nombreux mallocs, vous avez clairement affecter la mémoire pour une chaîne de caractères spécifique, et vous pouvez libérer un bloc de mémoire sans libérer l'ensemble de la "chaîne de tableau"

    • Avez-vous d'utiliser une autre boucle for pour libérer de la mémoire, que vous avez alloué?
    • Oui, à l'aide de boucles pour effectuer la même opération plusieurs fois est une bonne et une pratique commune, qui devient une nécessité lors de l'exécution d'un nombre variable de fois. (Mais pour chaque boucle peut être mis en œuvre comme un tout en boucle.)
    InformationsquelleAutor MByD
  2. 6

    Étant donné que les chaînes sont toutes de longueur fixe (sans doute au moment de la compilation?), vous pouvez effectuer les opérations suivantes:

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

//Clear-up
free(orderedIds);

    Un plus lourd, mais plus général, la solution consiste à attribuer à un tableau de pointeurs, et les pseudo-initialisation à point sur les éléments d'un raw de la sauvegarde de tableau:

    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);
    • C'est une façon discutable d'allouer les éléments d'un tableau à deux dimensions...
    • Pourquoi voulez-vous attribuer tout à orderedIds[0]?
    • Peu importe, votre montage est exactement ce que j'ai suggéré.
    • Bon endroit, merci!
    • Oui, en effet. En fait, je viens de faire ce changement!
    • Donc j'ai vu. Vous pouvez ajouter une remarque à propos de la façon dont on pourrait aller sur la bonne manière de libérer le fait que la première, car il est assez peu intuitive.
    • Que fait la première option est "malloc" de retour d'appel? Quel type de pointeur? Si j'essaie de le lancer en tant que quoi que ce soit (char*, char**...) j'ai des erreurs

    InformationsquelleAutor Oliver Charlesworth
  3. 5
    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]);
}
    InformationsquelleAutor sahaj
  4. 0
    
#define ID_LEN 5
char **orderedIds;
int i;
int variableNumberOfElements = 5; /* Hard coded here */

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

..
    • Il n'est pas considéré comme idiomatiques C pour lancer la valeur de retour de malloc. Aussi, vous êtes déclarant orderedIds comme un tableau plutôt qu'un pointeur, ce qui signifie que vous ne pouvez pas lui attribuer. Aussi, vous êtes mallocing un grand bloc pour toutes les données de caractère, puis un moulage d'un char ** qui est très différent.
    • Changé *orderedIds[] pour **orderedIds, mais je crois que le compilateur sage, il est le même, et l'ancien est juste plus lisible. Quant à la "un grand bloc" - c'est exactement ce qu'il est. Les tableaux sont juste des blocs de mémoire.
    • Vous avez tort. Si vous répartir comme un char[][ID_LEN + 1] vous ne pouvez pas le traiter comme un char **. char ** attend de vous que vous avez des pointeurs vers les données qui sont stockées ailleurs. Il n'est pas stocké dans la mémoire dynamique la même façon qu'un tableau à deux dimensions est stockée dans la pile.
    • Oui, vous avez raison
    InformationsquelleAutor Roman