gratuit un pointeur vers un tableau dynamique en c

J'ai créer un tableau dynamique en c avec la fonction malloc.
par exemple:

myCharArray = (char *) malloc(16);

maintenant, si je fais une fonction comme celle-ci et passer myCharArray:

reset(char * myCharArrayp)
{
    free(myCharArrayp);
}

ce travail, ou vais-je en quelque sorte seulement gratuit, la copie du pointeur (myCharArrayp) et non pas le myCharArray?

OriginalL'auteur Henrik | 2011-03-18

  1. 7

    Qui sera bel et libérer de la mémoire, comme vous l'attendez.

    J'avais envisager d'écrire une fonction comme

     void reset(char** myPointer) {
     if (myPointer) {
         free(*myPointer);
         *myPointer = NULL;
     }
 }

    De sorte que le pointeur est NULL, après avoir été libéré. La réutilisation précédemment libérée des pointeurs est une source fréquente d'erreur.

    En fait je suis en train de faire une revue de code, donc mon exemple est une version simplifiée. Dans le code il y a une autre ligne de code: myCharArrayp = NULL; je le savais, ne fonctionnerait pas. Mais ensuite, j'ai commencer à se demander si la liberté ne fonctionnerait pas. Je suppose que tout doit être réécrite de la façon dont vous le suggérer. Merci :o)
    La réponse de Joe l'explique bien. Le pointeur est une variable stockée sur la pile et de la fonction reçoit une copie. C'est pourquoi vous avez besoin d'un pointeur vers un pointeur dans l'exemple ci-dessus.
    Oui, vous auriez besoin d'un char ** (ou void **), mais pourquoi ne pas attribuer NULL du pointeur après l'appel de free dans le code? Pour citer: "Si ptr est un pointeur NULL, aucune opération n'est effectuée." donc je dirais que cette fonction est un peu du gaspillage!
    Si j'ai appelé reset(NULL) sans les vérifier si, j'allais essayer de déréférencer un pointeur null. L'idée de l'affectation de la valeur NULL par la suite de l'est, de sorte que le destinataire de l'appel voit la valeur NULL. De cette façon, les tentatives de réutiliser le pointeur échouer dans une plus prévisible de valeur que si il utilisait l'adresse précédemment libérée. C'est certainement un peu inutile, mais je suis en train de suggérer de négociation un peu plus de sécurité à la place. Peut toujours être prises dans la production.
    Oui, vous avez raison sur le déréférencement de pointeur nul, je n'ai pas le lire correctement.

    OriginalL'auteur Jeff Foster

  2. 14

    Vous avez besoin de comprendre qu'un pointeur n'est qu'une variable, qui est stockée dans la pile. Il pointe vers une zone de la mémoire, dans ce cas, allouées sur le tas. Votre code correctement libère la mémoire sur le tas. Lorsque vous revenez de votre fonction, le pointeur de variable, comme toute autre variable (par exemple, un int), est libéré. 

    void myFunction()
{
    char *myPointer;     //<- the function's stack frame is set up with space for...
    int myOtherVariable; //<- ... these two variables

    myPointer = malloc(123); //<- some memory is allocated on the heap and your pointer points to it

    free(myPointer); //<- the memory on the heap is deallocated

} //<- the two local variables myPointer and myOtherVariable are freed as the function returns.
    Merci pour la bonne explication.
    Merci pour cette bonne explication détaillant la différence de libérer de la mémoire, de la tête et de la pile. Pour moi, la coloration du code source serait mieux, donc plus facile à lire, si l' <- got remplacé par //.

    OriginalL'auteur Joe

  3. 1

    Oui cela va fonctionner.

    Si une copie de votre pointeur de variable sera envoyé, mais il désigne toujours le bon emplacement de mémoire qui sera effectivement libéré lors de l'appel de gratuit.

    OriginalL'auteur Shamim Hafiz