comment bien gratuit un char **tableau en C

Le problème est: est-ce

for(i = 0; i < sizeof(options) / sizeof(options[0]); i++)

options est un type de pointeur, pas de type tableau, donc sizeof(options) sera toujours le même (en général 4 octets sur une machine 32 bits ou 8 octets sur une machine 64 bits), donc sizeof(options)/sizeof(options[0]) sera presque toujours 1.

La clé est de toujours free mémoire de la même manière que vous malloc'ed elle. Donc, si vous malloc un tableau en 2 dimensions, puis malloc une série de 1-dimensions des tableaux, vous devez faire l'inverse lors de la libération de ça:

char ** generate_fields(char *) 
{
   char ** options = malloc(256*sizeof(char *));
   for(int i = 0; i < 256; i++)
       options[i] = malloc(some_size);
   return options;
}

void free_fields(char ** options)
{
    for(int i = 0; i < 256; i++)
        free(options[i]);
    free(options);
}

Noter que si la taille (256 dans ce cas) n'est pas une constante, vous avez besoin de garder une trace de vous-même, car sinon vous n'avez aucun moyen de savoir combien de fois en boucle lors de la libération.

Je vais ajouter à Adam de réponse ici, car c'est probablement ce qui ne rentre pas dans un commentaire. Adam est complètement à droite. Je soupçonne votre generate_fields fonction, cependant, peut-être effectivement l'entrée de l'utilisateur, je ne suis pas sûr. En tout cas, il y a deux façons de procéder:

char ** generate_fields(char *, int num_fields, int size_of_field) 
{
   char ** options = malloc(num_fields*sizeof(char *));
   for(int i = 0; i < num_fields; i++)
       options[i] = malloc(size_of_field);
   return options;
}

et libre de la fonction, que je vais laisser de côté pour des raisons de concision. Vous pouvez voir ce qui se passe: nous sommes de passage dans le nombre de champs et la taille du champ. Modifier la présente autour de que vous avez besoin. L'autre option consiste à générer des champs de passer de nouveau à la routine, il est appelé à partir de la taille de la matrice. J'aimerais faire quelque chose comme ceci:

int generate_fields(char** options) 
{
   int num_fields = 0;
   //somewhere here we get num_fields
   options = malloc(num_fields*sizeof(char *));
   for(int i = 0; i < num_fields; i++)
       options[i] = malloc(size_of_field);
   return num_fields;
}

Et vous appelez à partir d'principal comme ceci:

int main()
{
    int sizeofarray = 0;
    char** fields;
    sizeofarray = generate_fields(fields);

Ou si vous n'aimez pas que la notation, vous pouvez toujours vous en tenir à ce que vous avez eu:

char** generate_fields(int* size) 

Comme le prototype de fonction (options de retour de ce temps et de ne size= quelque part dans le code et d'appel de la principale comme ceci:

int sizeofarray = 0;
char** options;
options = generate_fields(&sizeofarray);

Espère que vous donne encore plus d'idées, Adam, n'hésitez pas à modifier tout ou partie de cette dans votre réponse appropriée, il s'agit de votre réponse de toute façon.