Malloc à l'intérieur d'un appel de fonction semble être d'obtenir libéré sur le retour?

Je pense que j'ai eu le plus de base:

int main(int argc, char ** argv) {
  int * arr;

  foo(arr);
  printf("car[3]=%d\n",arr[3]);
  free (arr);
  return 1;
}

void foo(int * arr) {
  arr = (int*) malloc( sizeof(int)*25 );
  arr[3] = 69;
}

La sortie est ceci:

> ./a.out 
 car[3]=-1869558540
 a.out(4100) malloc: *** error for object 0x8fe01037: Non-aligned pointer
                         being freed
 *** set a breakpoint in malloc_error_break to debug
>

Si quelqu'un peut jeter de la lumière sur l'endroit où ma compréhension est un échec, ce serait grandement apprécié.

InformationsquelleAutor |
  1. 47

    Vous passez le pointeur de la valeur, et non par référence, alors ce que vous faites avec arr à l'intérieur de foo va pas faire une différence à l'extérieur de l'foo-fonction.
    Comme m_pGladiator écrit est une façon de déclarer une référence de pointeur comme ceci (seulement possible en C++ btw. C ne connaît pas les références):

    int main(int argc, char ** argv) {
  int * arr;

  foo(arr);
  printf("car[3]=%d\n",arr[3]);
  free (arr);
  return 1;
}

void foo(int * &arr ) {
  arr = (int*) malloc( sizeof(int)*25 );
  arr[3] = 69;
}

    Un autre (mieux à mon humble avis) est de ne pas passer le pointeur en argument, mais pour renvoyer un pointeur:

    int main(int argc, char ** argv) {
  int * arr;

  arr = foo();
  printf("car[3]=%d\n",arr[3]);
  free (arr);
  return 1;
}

int * foo(void ) {
  int * arr;
  arr = (int*) malloc( sizeof(int)*25 );
  arr[3] = 69;
  return arr;
}

    Et vous pouvez passer un pointeur vers un pointeur. C'est le C de manière à passer par référence. Complique la syntaxe un peu, mais bon c'est la façon dont C est...

    int main(int argc, char ** argv) {
  int * arr;

  foo(&arr);
  printf("car[3]=%d\n",arr[3]);
  free (arr);
  return 1;
}

void foo(int ** arr ) {
  (*arr) = (int*) malloc( sizeof(int)*25 );
  (*arr)[3] = 69;
}
    • Je peux juste dire, merci de ne pas jeter la valeur de retour de malloc? Il n'est pas nécessaire et peut masquer les erreurs.
    • c'est une habitude que j'ai développé au fil des ans. Chacun puis-je envoyer mon code par le biais de l'analyse statique de code outils, et ils se plaignent pas de la coulée de pointeurs.
    • Désolé de vous quitter la pendaison sans réponse: il n'y a pas de bonne façon de trouver les réponses dans les commentaires, à moins que je sondage tous mes commentaires 🙂 j'ai laissé la réponse dans stackoverflow.com/questions/108768/...
    • Je sais que l'espoir - l'espoir d'une fonction pour signaler par les commentaires seront ajoutés un jour.
    • Qui des deux premiers sont le moyen le plus rapide des méthodes d'allouer de la mémoire à l'aide d'une fonction?
    InformationsquelleAutor Nils Pipenbrinck
  2. 6

    Que vous avez alloué arr foo, mais les pointeurs valeur est stockée dans la pile d'appel. Si vous voulez le faire, faites comme ceci:

    void foo( int ** arr) {
    *arr = (int *)malloc( sizeof(int) * 25 );
    (*arr)[3] = 69;
}

    Et dans la principale, il suffit de passer un pointeur vers foo (comme foo(&arr))

    InformationsquelleAutor terminus
  3. 3

    foo reçoit une copie locale de l'int pointeur, alloactes de la mémoire et des fuites de mémoire quand elle est hors de portée.

    Un moyen de corriger cela pour obtenir de foo pour retourner le pointeur:

    int * foo() {
  return (int*) malloc( sizeof(int)*25 );
}

int main() {
    int* arr = foo();
}

    Une autre est de passer foo un pointeur vers un pointeur

    void foo(int ** arr) {
   *arr = malloc(...);
}

int main() {
    foo(&arr);
}

    En C++, il est plus simple de modifier foo à accepter une référence à un pointeur. Le seul changement que vous avez besoin de C++ pour modifier foo

    void foo(int * & arr)
    InformationsquelleAutor Andrew Stein
  4. 1

    Depuis votre passez le pointeur de la valeur, l'arr pointeur à l'intérieur n'est pas en pointant vers la mémoire allouée. Cela signifie que deux chose: vous avez vous-même une fuite de mémoire (NON, la mémoire n'est pas libérée après la fonction foo complète), et lorsque vous accédez à l'arr pointeur à l'intérieur principal, vous accédez à certains arbitraire gamme de mémoire, donc vous n'obtenez pas 3 imprimé et donc free() refuse de travailler. Vous avez de la chance vous n'obtenez pas une erreur de segmentation lors de l'accès arr[3], à l'intérieur.

    InformationsquelleAutor Alexander
  5. 0

    Vous ne pouvez pas modifier la valeur de votre argument (arr), si ce n'est pas passé par référence (&). En général, vous voulez retourner le pointeur, de sorte que votre méthode doit être:

    arr=foo();

    C'est mauvais juju pour tenter de réaffecter des arguments; je ne recommande pas l' (&) solution.

    InformationsquelleAutor Bill K