porter de l'allocation

je me demande si j'alloue de la mémoire pour un pointeur dans une fonction qui retourne le même pointeur est ce que un pointeur affecter au même pointeur est bien alloué;
par exemple

Code:

---

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

int *fonction(int n) { ..... int *q=(int*)malloc(sizeof(int)*n); ....... return q; }   void main() { int *q=fonction(2); .... }

---

aussi cette situation;

Code:

---

1 2 3

int *q; int *p=(int*)malloc(sizeof(int)*2); q=p;

---

je cherche un comentaire qui explique ce qui se passe pour chaque exemple.

Code:

---

int *q;

---

Une variable de type "pointeur sur entier" est créée sur la pile, sa valeur est non définie.

Code:

---

int *p=(int*)malloc(sizeof(int)*2);

---

Une variable de type "pointeur sur entier" est créée sur la pile, sa valeur est l'adresse d'un bloc mémoire alloué sur le tas de taille 2 fois la taille d'un entier.

Code:

---

q=p;

---

La valeur de la variable q prend la même valeur que la variable p, soit l'adresse du même bloc mémoire que précédemment alloué.

Donc non il n'y a pas d'allocation mémoire quand tu fais q=p.
Les deux variables p et q pointent vers le même bloc mémoire alloué, et il ne faudra donc faire qu'un seul free et non deux.

En fait c'est peut-être plus clair d'écrire

Code:

---

int* q;

---

en collant le * au type int, dans la mesure où le type de q est "int*" donc "pointeur sur entier".
Enfin après c'est chacun qui voit ça :)

Est-ce que ça répond à ta question ?

MAT.

Code:

---

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

int *fonction(int n) { ..... int *q=(int*)malloc(sizeof(int)*n); ....... return q; }   void main() { int *q=fonction(2); .... }

---

il reste a ce que je comprend ce qui ce passe dans cette exemple.

Citation:

---

Envoyé par lastrecrue

Code:

---

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

int *fonction(int n) { ..... int *q=(int*)malloc(sizeof(int)*n); ....... return q; }   void main() { int *q=fonction(2); .... }

---

il reste a ce que je comprend ce qui ce passe dans cette exemple.

---

Il n'y a rien à comprendre, avec les explications de Mat007 cela devrait couler de source !

Dans ta fonction fonction tu alloues un bloc mémoire dont tu retournes l'adresse qui sera affecté à ton pointeur q det on main tout simplement ! Le pointeur q de ta fonction d'allocation reste quant à lui local à sa fonction rien de plus.

Un pointeur n'est autre qu'une variable qui contient une adresse mémoire au lieu de contenir directement une données comme les variables normales donc c'est un simple passage de valeurs si tu veux !

Citation:

---

Envoyé par lastrecrue

je me demande si j'alloue de la mémoire pour un pointeur

---

Attention à la terminologie. "Allouer de la mémoire pour un pointeur", c'est, par exemple ça :

Code:

---

int**pp = malloc (sizeof *pp);

---

Citation:

---

dans une fonction qui retourne le même pointeur est ce que un pointeur affecter au même pointeur est bien alloué;

---

C'est pas bien clair tout ça...

Citation:

---

par exemple

---

Pourquoi un cast devant le malloc() ?
Pourquoi main() retourne void ?

Depuis le temps que tu fréquentes ce forum, tu ne sais pas encore que ce cast est inutile et que main() retourne int ? On a mal fait notre boulot ou quoi ?

Pour en revenir à ton code (corrigé),

Code:

---

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

int *fonction(int n) { /* allocation d'un bloc de la taille d'un tableau de n int   l'adresse du bloc est stockee dans q et retournee a l'appelant   */ int *q = malloc (sizeof *q *n); return q; }   int main() { /* l'adresse du tableau de 2 int est recuperee dans q */ int *q = fonction(2);   return 0; }

---

http://emmanuel-delahaye.developpez.....htm#pointeurs

Citation:

---

Envoyé par Mat007

En fait c'est peut-être plus clair d'écrire

Code:

---

int* q;

---

en collant le * au type int, dans la mesure où le type de q est "int*" donc "pointeur sur entier".
Enfin après c'est chacun qui voit ça :)

---

En fait, c'est justement trompeur ! :)

Si on écrit ça :

Code:

---

1 2	int* i, j;

---

i et j ne seront pas deux pointeurs sur entier, mais un pointeur et un entier !

Citation:

---

Envoyé par Faiche

En fait, c'est justement trompeur ! :)

Si on écrit ça :

Code:

---

1 2	int* i, j;

---

i et j ne seront pas deux pointeurs sur entier, mais un pointeur et un entier !

---

C'est pour cette raison que j'opte et recommande une ligne par déclaration de variables, pointeurs, etc... comme :

Code:

---

1 2	int * i = NULL; int j = 0;

---

Sans compter bien sûr une initialisation par défaut qui permet dans bien des cas d'empêcher de vulgaires problèmes de comportement de l'application ! Sous cette forme, il y'a bien moins d'ambiguïtés !