[C] Allocation dynamique de memoire

Bonjour !

J'effectue des tests sur l'allocation memeoire...

Dans une fonction,je déclare un char *.
Je passe ce pointeur à une fonction qui se charge d'allouer la memoire. En retour de la fonction, j'ai une erreur lorsque je fais un memeset sur ce pointeur ! Je ne comprends pas pourquoi ?

Voila mon code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

void modifalloc(char *pointeur) {   pointeur = (char *)malloc(10*sizeof(char));   }   void essai(void) { char *sztoto;   modifalloc(sztoto); memset(sztoto, '*', 10);   free(sztoto);   }

---

Merci de votre aide.
:D

Tu t'y prends mal. En C, le passage de paramètre se fait par recopie de valeur. Donc forcement, ca ne peut pas marcher.
Essayes comme cela :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

char *modifalloc(void) { char *pointeur = NULL; pointeur = malloc(10); /* Faut egalement tester le retour de malloc */   return (pointeur); }   void essai(void) { char *sztoto; sztoto = modifalloc(); [...] free(sztoto); }

---

Quel est le probleme dans mon cas ?
Cela veut-il dire que l'adresse que je passe est parametre est recopiée par l'adresse fournie par malloc ? (Ais-je bien compris ?)
Je comprends ce que tu as fais... Cependant dans le cas ou 2 variables sont à prendre en compte, je ne pourrai pas utiliser cette méthode !

J'avais une autre question !:roll:
J'ai effectué mon free a la fin de ma fonction mere... Je me demandais si cela étais correct, dans le sens ou la taille de ma variable avait changée !!! Et en cherchant plus loin, est-il possible de ne pas faire le free, puisque la variable est déclarée dans la fonction, elle ser liberee à la sortie ???

Merci de ton aide crocodilex...

Salut,


Tu peux également faire:

Citation:

---

Envoyé par xc78370

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#include <string.h> #include <stdio.h> #include <stdlib.h>   /* -TC- Dans ton cas, l'adresse contenue dans pointeur est passée par valeur. Si tu modifie pointeur, la valeur de sztoto n'est pas modifiée. Procéder comme suit: (ou comme crocodilex) */ void modifalloc(char **pointeur) { /* -TC- Pas conseillé de caster le retour de malloc */ *pointeur = malloc(10*sizeof(**pointeur)); strncpy(*pointeur, "Salut", 10);   }   void essai(void) { char *sztoto; /* -TC- Tu dois maintenant passer l'adresse de sztoto */ modifalloc(&sztoto); puts(sztoto);   free(sztoto), sztoto = NULL;   }

---

---

Citation:

---

Envoyé par xc78370

Quel est le probleme dans mon cas ?
Cela veut-il dire que l'adresse que je passe est parametre est recopiée par l'adresse fournie par malloc ? (Ais-je bien compris ?)
Je comprends ce que tu as fais... Cependant dans le cas ou 2 variables sont à prendre en compte, je ne pourrai pas utiliser cette méthode !

J'avais une autre question !:roll:
J'ai effectué mon free a la fin de ma fonction mere... Je me demandais si cela étais correct, dans le sens ou la taille de ma variable avait changée !!! Et en cherchant plus loin, est-il possible de ne pas faire le free, puisque la variable est déclarée dans la fonction, elle ser liberee à la sortie ???

Merci de ton aide crocodilex...

---

Le free est tout à fait correct du moment que que sztoto pointe sur un block alloué par malloc...

Thierry

Citation:

---

Envoyé par xc78370

Et en cherchant plus loin, est-il possible de ne pas faire le free, puisque la variable est déclarée dans la fonction, elle ser liberee à la sortie ???

---

Une règle : celui qui alloue la mémoire est chargé de la désallouer.
Ou plus simplement : un malloc, un free.

Merci mujigka...

J'étais justement en train d'essayer de passer l'adresse du pointeur en parametre !!! Tu me fais avancer plus vite... Merci

Citation:

---

Envoyé par zooro

Une règle : celui qui alloue la mémoire est chargé de la désallouée.
Ou plus simplement : un malloc, un free.

---

Oui mais dans mon cas, la taille d'alocation n'est connue que dans ma fonction fille et j'ai besoin de ma variable allouée dans la suite de ma fonction emer !!!


Merci à tous

Citation:

---

Envoyé par xc78370

Merci mujigka...

J'étais justement en train d'essayer de passer l'adresse du pointeur en parametre !!! Tu me fais avancer plus vite... Merci

Oui mais dans mon cas, la taille d'alocation n'est connue que dans ma fonction fille et j'ai besoin de ma variable allouée dans la suite de ma fonction emer !!!

Merci à tous

---

Le free n'a pas besoin que tu lui donnes la taille de la zone à libérer. Un pointeur avec la bonne adresse suffit.

Ce que je voulais dire, c'est que tu as appelé une fonction pour allouer de la mémoire, donc c'est à toi d'appeler une fonction (free en l'occurrence) pour la désallouer.

Citation:

---

Envoyé par xc78370

Merci mujigka...

J'étais justement en train d'essayer de passer l'adresse du pointeur en parametre !!! Tu me fais avancer plus vite... Merci


Oui mais dans mon cas, la taille d'alocation n'est connue que dans ma fonction fille et j'ai besoin de ma variable allouée dans la suite de ma fonction emer !!!


Merci à tous

---

Tu n'as qu'un prévoir un paramètre supplémentaire à ta fonction pour transmettre la taille allouée à la fonction appelante. Et tu n'as pas besoin de connaître la taille du bloc alloué pour libérer la mémoire.

Thierry

Salut,

A vrai dire, le gros problème c'est que, si tu passe un parametre à une fonction, tu déclare explicitement une variable locale à cette fonction du type et de la valeur de l'argument passé...

Cela signifie que, si tu veux qu'elle modifie la valeur d'une variable normale, tu dois lui passer l'adresse de la variable (un pointeur sur la variable), et, si tu veux qu'une fonction modifie un pointeur, tu dois en fait lui passer... l'adresse du pointeur (c'est à dire un pointeur de pointeur)... ou alors décider de renvoyer l'élément désiré (et de le récupérer dans la fonction appelante par variable=fonction();)

Voici donc, de manière générale, les deux possibilités pour modifier une valeur de variable:

Code:

---

1 2 3 4 5

void Modif( type* parg) { /*ici, il faut travailler sur "ce qui se trouve à l'adresse pointée par parg */ }

---

appelée sous la forme de

Code:

---

1 2	type valeur; Modif(&valeur);

---

ou

Code:

---

1 2 3 4 5 6 7

type Modif() { type renvoi; /* on modifie renvoi et on le renvoi */ return renvoi; }

---

dont l'appel se fera sous la forme de

Code:

---

1 2 3

type variable; variable=Modif();

---

Avec les pointeurs, c'est la meme idée, sauf que, dans le premier cas, on passera un... pointeur de pointeur comme argument

Code:

---

1 2 3 4 5 6 7 8

void ModifPointeur(type ** pparg) { /*pour modifier la valeur dans la fonction appelante, on travaillera sur   "ce qui est pointé par pparg"... ex: */ *pparg=malloc(sizeof(type));/*évidemment, cette commande ci n'est pas   des plus sécus ;) */ }

---

appelée sous la forme de

Code:

---

1 2 3

type *ptr; ModifPointeur(&ptr);

---

mais on peut aussi utiliser une fonction qui renvoie le pointeur...

Code:

---

1 2 3 4 5 6 7 8

/*nombre correspond ici au nombre d'éléments que l'on souhaite */ type* AllouePointeur(int nombre) { Type *ptr; ptr=malloc(nombre*sizeof(ptr)); return ptr; }

---

et qui sera appelée de manière conventionnelle:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

type *ptrvar; ptrvar=AllouePointeur(15); if(ptrvar!=NULL) { /*c'est ok */ } else { /* c'est pas ok */ }

---

L'utilisation des pointeurs sur quelque chose comme argument présente l'avantage de permettre la modification de valeurs tout en renvoyant, par exemple, le résutat global (réussite/échec) de la fonction... ex:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

/* Renvoie 1 en cas de réussite, 0 en cas d'échec */ int Modification(int* parg, type2** ptr2) { /*va tenter de modifier la valeur qui sera fournie en tant que parg,   et de réallouer le pointeur fourni en tant que ptr2 */ *parg+=5; type2 *nouveau; nouveau=malloc((*parg)*sizeof(type2)); if(nouveau==NULL) { /* il faut retirer les 5 qu'on a rajouté à parg pour revenir à l'état   initial */ *parg-=5; return 0; } /*libération de ce qui est pointé par ptr2 */ if(*ptr2!=NULL) free(*ptr2); *ptr2=nouveau; return 1; }

---

et qui sera appelée sous la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

int variable=10; type2 *ptrvar=NULL; int resultat; resultat=Modification(&variable, &ptrvar); if(resultat==1) { /* ici, variable vaut 15 et ptrvar dispose de suffisemment de mémoire pour   contenir 15 éléments */ } else { /* rien n'a changé ici */ }

---