Modification de pointeur [debutant]

Salut,

Je suis débutant et j'ai une question à propos de l'utilisation d'un pointeur. Je souhaite que les modifications soient bien prises en compte sur celui-ci, sans pb mémoire.

Dans un 1er fichier, main.C, j'ai :

Code:

---

1 2 3 4

pointeur * my_ptr; // pointeur sur une structure   my_ptr = appel_fonction( my_ptr );

---

Dans un 2eme fichier, traiter.C, j'ai :

Code:

---

1 2 3 4 5 6

my_ptr * appel_fonction( pointeur * my_ptr ) { // modifications diverses sur my_ptr // (...) return my_ptr; }

---

Est-ce que les modifications réalisées par ma fonction appel_fonction() sur mon pointeur my_ptr seront bien prises en compte une fois revenu dans mon main.C ?
Si non, comment faire ? Doit-on utiliser un passage par référence ???

Merci pour votre aide

Citation:

---

Est-ce que les modifications réalisées par ma fonction appel_fonction() sur mon pointeur my_ptr seront bien prises en compte une fois revenu dans mon main.C ?

---

Oui, puisque tu le fais renvoyer par la fonction et le récupères après l'appel.

Bien sûr là on parle de la valeur du pointeur, si tu modifies ce qui est pointé ce sera aussi quoiqu'il arrive pris en compte dans ta fonction appelante.

Code:

---

1 2 3 4 5

my_ptr * appel_fonction( pointeur * my_ptr ) { // modifications diverses sur my_ptr // (...) return my_ptr; }

---

C'est ambigü ton example, my_ptr est à la fois le type de retour et le nom de la variable en paramètre. Ca pourrait t'embrouiller.

Citation:

---

Envoyé par Cheps

Code:

---

1 2 3 4 5

my_ptr * appel_fonction( pointeur * my_ptr ) { // modifications diverses sur my_ptr // (...) return my_ptr; }

---

C'est ambigü ton example, my_ptr est à la fois le type de retour et le nom de la variable en paramètre. Ca pourrait t'embrouiller.

---

Oups... pardon, oui en fait la signature est :
pointeur * appel_fonction( pointeur * my_ptr )

Citation:

---

Envoyé par Laurent Gomila

Oui, puisque tu le fais renvoyer par la fonction et le récupères après l'appel.

Bien sûr là on parle de la valeur du pointeur, si tu modifies ce qui est pointé ce sera aussi quoiqu'il arrive pris en compte dans ta fonction appelante.

---

Ok merci

Pour info, dans quel cas utiliser un passage par référence alors ? Seulement si je ne fais pas retourner le pointeur par la fonction appel_fonction ?
La signature devenant :
void appel_fonction( pointeur & my_ptr ) ?

:faq:

http://c.developpez.com/faq/cpp/?pag...CE_utilisation

Citation:

---

Pour info, dans quel cas utiliser un passage par référence alors ?

---

Dans tous les cas.
Les pointeurs c'est à n'utiliser que si tu ne peux pas faire ce que tu veux avec les références.

Salut,

En fait, les deux grosses questions à se poser sont:

Citation:

---

Ma fonction accepte-t-elle un pointeur pointant sur NULL (ou plutot "Est-ce que je risque de passer une valeur NULL à ma fonction"):question:

---

Il faut savoir que la grosse différence entre une référence et un pointeur, c'est que la référence n'accepte pas une valeur NULL: avec une fonction du genre de

Code:

---

1 2 3 4 5

void mafonct( type& ref) { //tout ce qu'il faut }

---

tu ne pourras pas envisager un code ressemblant à

Code:

---

1 2 3

type *ptr=NULL; mafonct(*ptr);

---

De plus, si ton type est une structure (au sens "générique" du terme, incluant les classes)
Tu as peut etre, effectivement intérêt à refuser une valeur nulle, parce que ref->data ou ref->fonct() sur un pointeur NULL risque de provoquer de sérieux problèmes :P
Si tu ne précise pas que ta référence est constante, les modifications que tu pourrais envisager effectuer dans ta fonction au sein de ta structure seront automatiquement prise en compte dans la structure fournie en parametre

Exemple:
Soit une structure, simple, du genre de

Code:

---

1 2 3 4 5 6

struct mastruct { int nombre; std::string chaine; };

---

et un fonction, tout aussi simple, du genre de

Code:

---

1 2 3 4 5 6

void mafonct(mastruct& ref) { ref.nombre++; ref.chaine="au revoir"; }

---

comme tu peux le remarquer, je ne cherche vraiment pas la difficulté ici :D

Evidemment, il faut mettre ca dans un contexte du genre de:

Code:

---

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

int main() { mastruct valeur; valeur.nombre=1; valeur.chaine="bonjour"; // appel de la fonction mafonct(valeur); //affichage du résultat std::cout<<valeur.nombre<<" "<<valeur.chaine<<std::endl; return 0; }

---

L'affichage sera

Code:

---

2 au revoir

---

Bref, le résultat sera exactement pareil à la fonction sous la forme de

Code:

---

1 2 3 4 5

void mafonctptr(mastruct* ptr) { ptr->nombre++; ptr->chaine="au revoir"; }

---

appelé sous la forme de

Code:

---

1 2	mafonctptr(&valeur);

---

Sauf que...

Sauf qu'un pointeur peut tres bien pointer sur NULL, parce qu'on n'a pas encore alloué la mémoire correspondante, ou parce que l'allocation a échoué, voire sur une donnée qui n'a plus rien à voir avec le type envisagé à la base (l'exemple classique étant de vouloir accéder à un élément en trop dans un tableau)

La fonction utilisant la version par référence, si elle ne te permet pas de déterminer que tu accède à un élément de trop dans un tableau, te permettra au moins de t'assurer que le pointeur sur ton tableau ne soit pas nul...

De plus, tu pourras te contenter d'un acces "sur structure" tout à fait classique (mavaleur.valeur.truc) (où valeur serait un membre de structure non pointeur) là où tu aurais du commencer à réfléchir à ce qui est pointeur et ce qui ne l'est pas (mavaleur->valeur.truc)

Bref, tu l'auras compris, autant que faire se peut, il est préférable de travailler avec des références (constantes si tu ne prévois pas de les modifier) qu'avec des pointeurs ;)

Si tu veux une valeur nulle tu prends boost::optional.
En fait les pointeurs ne servent que si tu veux pouvoir changer le pointeur. Avec une référence, c'est comme si t'avais un pointeur constant (à ne pas confondre avec un pointeur vers un objet constant).
Du coup en fait ça sert jamais les pointeurs dans l'interface d'une fonction.