La portée de malloc utilisé dans une fonction

Lorsqu'une fonction retourne une valeur, est la mémoire allouée par malloc libéré? Ou peut-il encore être accessibles dans la fonction main() en utilisant les pointeurs?

par exemple.

void function(int *a)
{
    a=(int *)malloc(sizeof(int));
    *a=10;
}
int main()
{
    int *num;
    function(num);
    printf("%d",*num);
    return(0);
}

Peut l'entier stocké dans un être consulté par main() ici?

InformationsquelleAutor | 2010-09-02

c malloc

36

Non, la mémoire allouée avec malloc n'est pas libérée lorsque vous quittez le champ d'application/de retour de la fonction.

Vous êtes responsable de la libération de la mémoire malloc.

Dans votre cas, cependant, la mémoire n'est PAS accessible dans main(), mais c'est parce que vous ne traitez qu'avec une variable locale.
```
void function(int *a)
{
    a=(int *)malloc(sizeof(int));
```
Ici, a est une variable locale à l'intérieur de function . Les pointeurs sont passés par valeur en C, donc a reçoit une copie du pointeur en principal lorsque vous ne function(num); main() ne permet pas de voir que vous attribuez à cette copie locale du pointeur.

Que vous avez à faire soit:
```
void function(int **a)
{
  *a= malloc(sizeof(int));
  **a=10;
}
int main()
{
  int *num;
  function(&num);
  printf("%d",*num);
  free(num);
  return(0);
}
```
ou
```
int* function(void)
{
  int *a= malloc(sizeof(int));
  *a=10;
  return a;
}
int main()
{
  int *num;
  num = function();
  printf("%d",*num);
  free(num);
  return(0);
}
```
InformationsquelleAutor nos
3

malloc()ed la mémoire est libérée lorsque vous appelez free() sur elle. Il peut être consulté par toute personne ayant un pointeur valide jusqu'à ce moment.

InformationsquelleAutor Steve Townsend
3

Pas. Vous passez le pointeur de la numen valeur, d'où les modifications apportées par le function ne seront pas reflétées dans main. Donc, effectivement il n'y a aucun moyen d'accéder à/libérer la mémoire allouée à partir de main

Pour y remédier, vous pouvez passer l'adresse de num ou de retour a à partir de la fonction et de recueillir la valeur retournée dans num

InformationsquelleAutor codaddict

malloc fonctionne bien (si vous devez les appeler free() sur le pointeur, il retourne). Le problème ici est que vous ne pouvez pas retourner un pointeur vers la mémoire allouée.

"int * a", votre paramètre de la fonction() est l'adresse d'un entier. La façon habituelle de retour qui serait à réécrire votre fonction comme suit:

int * function()
{
  int * a = (int *)malloc(sizeof(int));
  *a = 10;
  return a;
}

De retour par l'intermédiaire d'un paramètre, vous devez renvoyer l'adresse du pointeur:

// pp points to a pointer
void function( int ** pp )
{
    // Assign allocated memory to the thing that pp points to
    *pp = (int *)malloc( sizeof( int ) );

    // Get the thing pp points to -- a pointer.
    // Then get the thing which THAT pointer points to -- an integer
    // Assign 10 to that integer. 
    **pp = 10;
}

void main()
{
    int * p = NULL;

    function( & p );

    printf( "%d\n", *p );

    free( p );
}

Et maintenant vous savez pourquoi ils ont inventé C#.

Voici une façon de réécrire votre allocation chose si c'est plus clair:

void function( int ** pp )
{
    int * newmemory = (int *)malloc( sizeof( int ) );

    // Assign 10 to the integer-sized piece of memory we just allocated. 
    *newmemory = 10;

    // Assign allocated memory to the thing that pp points to. 
    *pp = newmemory;
}

InformationsquelleAutor Ed Plunkett

0

Mémoire n'est pas libérée. Toute fonction peut allouer de la mémoire et tout autre peut désallouer. C'est un véritable gâchis si vous n'êtes pas super pointilleux, jusqu'à ce que... quelqu'un a inventé la Collecte des Ordures.

InformationsquelleAutor vulkanino
0

Vous pouvez stocker l'adresse directe de la mémoire allouée dans une liste de conteneurs, puis de créer une fonction de boucle, l'accès à chaque adresse dans une fonction libre, puis de la pop à l'adresse. Vous pouvez insérer l'adresse directement dans la fonction libre comme free(myaddresslist.front()); myaddresslist.pop_front(); . C'est un quasi façon de faire votre propre collecte des ordures sans avoir à changer l'ensemble de votre projet de GC en fonction des langues. Utilisation myaddresslist.size() pour vous assurer de ne pas appeler free() sur un champ vide (résultant dans un accident) et de déterminer le nombre de boucles à prendre.

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.