Discussion :

[tomrouge]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Laurent Gomila]

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.

[tomrouge]

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 ) ?

[Cheps]

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

[loufoque]

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.

[koala01]

Salut,

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

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
void mafonct( type& ref)
{
//tout ce qu'il faut
}

tu ne pourras pas envisager un code ressemblant à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
struct mastruct
{
    int nombre;
    std::string chaine;
};

et un fonction, tout aussi simple, du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

2 au revoir

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void mafonctptr(mastruct* ptr)
{
    ptr->nombre++;
    ptr->chaine="au revoir";
}

appelé sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Cheps]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[tomrouge]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 )