Allocation dynamique de mémoire pour un tableau de caractères 2D

= ne copie pas la chaîne, il affecte uniquement le pointeur. Donc, votre mémoire malléable n'est plus accessible pour ces éléments de tableau et tenter de la libérer est un comportement indéfini qui peut conduire à l'erreur de segmentation.

Vous devez le copier en utilisant strcpy .

Lorsque vous faites cela:

strcpy(arr[0], "string1");
strcpy(arr[1], "string2");

Vous écrasez le contenu de arr [0] et arr [1] , qui contiennent les adresses de mémoire renvoyées par malloc , avec l'adresse de deux constantes chaîne. Cela provoque une fuite de mémoire, car cette mémoire n'est plus accessible. C'est aussi la raison pour laquelle vous plantez lorsque vous appelez free parce que ces variables ne contiennent plus les adresses de la mémoire allouée.

Ce que vous voudrez probablement faire ici à la place est d'utiliser strcpy , qui copiera le contenu de la chaîne littérale dans la mémoire que vous avez allouée.

arr[0] = "string1";
arr[1] = "string2";

Vous pouvez maintenant libérer la mémoire correctement .

Deux choses à savoir:

• Vous avez deux zones en mémoire (pour faciliter la compréhension): pile et pile
• malloc, realloc, calloc allouent une ressource à partir du tas. Je dirai seulement malloc (mais c'est pareil)
  • free ne peut libérer que des ressources du tas. Stack est un reserver pour le compilateur (il stocke l'appel de fonction et d'autres données)

La règle pour chaque ressource que vous obtenez de malloc vous devez la libérer. pour libérer appelez simplement la fonction libre (mais nous pouvons éventuellement attribuer un pointeur nul pour être sûr qu'il est libéré).

#include <stdio.h>
#include <stdlib.h>

int main(void) {

    int nrows = 20; int ncolumns = 10;
    char ** arr = malloc(nrows * sizeof(char *));
    for(int i = 0; i < nrows; i++)
        arr[i] = malloc(ncolumns * sizeof(char));
    free(arr[0]);//know we can loose it value because it is freed
    arr[0] = NULL;// in fact we assign a value just after so this line is useless but is educationnal purpose
    free(arr[1]);//know we can loose it value because it is freed
    arr[1] = NULL;// in fact we assign a value just after so this line is useless but is educationnal purpose
    arr[0] = "string1";
    arr[1] = "string2";

    // does not work without the following code:
    // for(int i = 0; i < 20; i++)
    //     arr[i] = NULL;

    for(int i = 2; i < 20; i++)//we start at 2 because the first two value are on the stack
    {
        free(arr[i]);
        arr[i] = NULL;//this is useless because we will free arr just after the loop)
    }
    free(arr);
    arr = NULL;// this is useless because we exit the end of program

    return 0;
}

pour libérer

free(a);/* this is mandatory */
a = NULL;/* we can add this to the first line */

Votre code est correct, le problème vient du fait que vous attribuez ici des chaînes littéraux à votre tableau: arr [0] = "string1"; .

Vous remplacez ainsi le pointeur sur arr [0] , qui pointe vers la mémoire allouée, par le pointeur vers une chaîne littérale.

Les pointeurs vers les littéraux sont protégés , vous ne pouvez pas les libérer (ni leur écrire) car vous ne les avez pas alloués.

Pour résoudre ce problème, utilisez strcpy pour copier la valeur de votre littéral dans votre alloué mémoire:

strcpy(arr[0], "string1");
strcpy(arr[1], "string2");

Un crash lors d'un appel à free est le signe d'une mauvaise gestion de la mémoire ailleurs dans votre code. Lorsque vous définissez un pointeur sur NULL puis sur free , vous n'allez pas planter, car free (NULL) est garanti inoffensif par la norme C § 7.22.3.3:

7.22.3.3 La fonction libre

... Si ptr est un pointeur nul, aucune action ne se produit . Sinon, si l'argument ne correspond pas à un pointeur précédemment renvoyé par une gestion mémoire fonction , ou si l'espace a été libéré par un appel à free ou à réallouer, le le comportement n'est pas défini.

Insistez sur moi.

Comme d'autres réponses l'ont noté, vous essayez d'appeler free sur une mémoire que vous n'avez pas explicitement allouée avec des fonctions familiales malloc (depuis que vous avez écrasé arr [i] pointeurs avec des pointeurs vers des chaînes littérales)