simple c malloc

Question

cela ne fonctionne pas:

void function(char* var) 
{ 
    var = (char*) malloc (100); 
} 

int main() 
{ 
    char* str; 
    function(str); 
    strcpy(str, "some random string"); 
    printf("%s\n", str); 

    return 0; 
} 

ce fait:

void function(char* var) 
{ 
    //var = (char*) malloc (100); 
} 

int main() 
{ 
    char* str; 
    //function(str); 
    str = (char*) malloc (100); 
    strcpy(str, "some random string"); 
    printf("%s\n", str); 

    return 0; 
} 

Pourquoi?

Answer 1

Vous devez passer l'adresse du pointeur pour attribuer l'adresse que vous souhaitez l'intérieur la fonction, sinon vous êtes juste de passage une copie:

void function(char** var) 
{ 
    *var = malloc (100); 
} 

int main() 
{ 
    char* str; 
    function(&str); 
    strcpy(str, "some random string"); 
    printf("%s\n", str); 

    return 0; 
} 

Answer 2

Vous devez utiliser un pointeur vers le pointeur comme paramètre pour cela, char **.
Lorsque vous passez un pointeur en tant que paramètre, il est copié, ce que vous obtenez à l'intérieur de la fonction est juste un autre pointeur pointant vers le même endroit.

Vous devez recevoir un char ** et faire:

my_alloc_fun(void **ptr){ 
    *ptr= malloc(size); 
} 
void *myptr; 
my_alloc_fun(&myptr); 

De cette façon, vous obtenez l'adresse du pointeur à l'intérieur de la fonction, de sorte que vous pouvez faire le pointeur d'origine pour pointer vers la mémoire nouvellement allouée.

Answer 3

Lorsque vous appelez function(str), vous passez la valeur de str à function. Cette valeur est une valeur de mémoire non initialisée car vous ne l'avez pas définie sur main, mais ce n'est pas le problème.

Le problème est que function a son propre pointeur, var, dans lequel il place cette valeur de la fouillis afin que l'on puisse dire var points to the same thing (garbage) that str points to. Cependant, ils ne sont pas la même variable. Ils sont deux variables distinctes, et la modification var n'a aucun effet sur str.

Lorsque vous indiquez var = (char*) malloc (100);, vous allouez de la mémoire quelque part, puis vous indiquez à var de le désigner. Maintenant, var indique un emplacement différent de str. Immédiatement, vous revenez de cette fonction, perdant var et l'emplacement de cette mémoire. C'est d'ailleurs une fuite de mémoire. Quand vous revenez à main, str est comme toujours - pointant vers la poubelle.

Un exemple numérique:

char *str;  // str -> 0xfeedface (garbage) 
function(str); 

// inside 'function', an initialization like this occurs 
char *var = str; // var -> 0xfeedface (same garbage) 
var = (char*) malloc (100); // var -> 0x12341234 (alloc'd memory) 
return; 

// back in 'main' 
strcpy(str, "some random string"); // str still points to 0xfeedface! 

Pour le faire correctement, vous devez changer la valeur de str. Cela signifie que function nécessite un pointeur vers str ou un pointeur vers un pointeur.

void function(char **var) 
{ 
    *var = (char*)malloc(sizeof(char) * 100); 
} 

int main() 
{ 
    char *str; 
    function(&str); 
    strncpy(str, "some random string", 99); 
    ... 
    free(str); // important in general 
} 

Answer 4

Voir ma réponse à C Programming: malloc() inside another function une explication sur la façon de penser à ce sujet.

Answer 5

Les pointeurs sont comme n'importe quelle autre variable; la différence est seulement dans ce que représente leur valeur. Alors qu'un double a une valeur qui représente un nombre à virgule flottante double précision, et un int a une valeur qui représente un entier signé, un pointeur a une valeur qui représente l'emplacement d'une autre variable.

Les pointeurs eux-mêmes sont toujours passés valeur par rapport à d'autres fonctions; de sorte que votre exemple ne fonctionne pas exactement pour la même raison que cette fonction ne fonctionne pas analogue:

void function(int var) 
{ 
    var = 100; 
} 

int main() 
{ 
    int num; 
    function(num); 
    printf("%d\n", num); 

    return 0; 
} 

La réponse dans les deux cas est le même: Lorsque function() modifie la valeur du paramètre var, il est en train de changer seulement sa copie locale de cela - il ne change pas la variable dans main().