Discussion :

[deubelte]

les cas suivants font exacetement la même chose:

---Passage par référence-----------

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int f(int& x){
x=3;
return 0;
}
 
int main()
{
int a=4;
 
f(a);
std::cout<<a;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int f(int& x){
x=3;
return 0;
}
 
int main()
{
int a=4;
int *b=&a;
f(*b);
std::cout<<a;
}

---Passage par adresse-------------:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int f(int* x){
x=3;
return 0;
}
 
int main()
{
int a=4;
int *b=&a;
f(&a);
std::cout<<a;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int f(int* x){
x=3;
return 0;
}
 
int main()
{
int a=4;
int *b=&a;
f(b);
std::cout<<a;
}

quel est celui qui est à privilégier, et dans quel cas?
perso, je préfère le passagepar référence, je trouve ca plus naturel que de passer par un pointeur, alors qu'on peut le faire avec la variable elle meme
deplus, ca ne crée pas de variable supplémentaires
et dans le passage par adresse, je préfere le premier cas.
enfin c mon avis de débutant
et vous?

[buggen25]

Salut.
Je prefere le passage d'argument par adresse, c'est plus commun et plus habituel

[Trunks]

Pour la version par adresse, on affecte la valeur en déférençant le pointeur :

Code :

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

1
2
3
4
int f(int* x){
*x=3;
return 0;
}

L'avantage du paramètre par référence est que la fonction s'écrit de manière naturelle (pas besoin de déférencer).

L'avantage du paramètre par pointeur est que lorsqu'on appelle la fonction, on sait qu'on veut modifier le paramètre par on passe l'adresse de la variable.

[Montag]

L'avantage du paramètre par pointeur est que lorsqu'on appelle la fonction, on sait qu'on veut modifier le paramètre par on passe l'adresse de la variable.

??
C'est la présence ou non du qualifieur const qui permet de savoir si une fonction/méthode modifie le paramètre qu'on lui passe.

[mister3957]

En général on utilise que des références sauf dans le cas où le paramètre peut être nul.

[Klaim]

Pareil qu'au dessus, ici il n'y a absolument aucune bonne raison d'utiliser un pointeur, il y a juste a mettre une reference const ou pas selon si la fonction a besoin ou pas de modifier le paramettre.

Utiliser un pointeur veut souvent dire soit que le pointeur peut être null (dans le cas ou il y a un test à l'execution qui prendrait en compte ce cas), ou qu'on va manipuler directement la mémoire liée. Dans les autres cas, il n'y a pas de raison d'utiliser un pointeur.

En fait, par défaut, n'utilisez pas de pointeur. Ne le faites seulement si vous y êtes forcé, ça vous épargnera beaucoup de potentiel bugs.

[Trunks]

??
C'est la présence ou non du qualifieur const qui permet de savoir si une fonction/méthode modifie le paramètre qu'on lui passe.

Le const est utile lorsqu'on passe une structure ou classe en paramètre. Vu que ce paramètre est lourd, on va éviter une copie de ce dernier, c'est pour celà qu'on le passe par référence ou via un pointeur. Cependant, comme il n'est pas amené à être modifié, on le déclare en const pour le signaler et ainsi éviter un éventuel accident.

[Montag]

Le const est utile lorsqu'on passe une structure ou classe en paramètre. Vu que ce paramètre est lourd, on va éviter une copie de ce dernier, c'est pour celà qu'on le passe par référence ou via un pointeur. Cependant, comme il n'est pas amené à être modifié, on le déclare en const pour le signaler et ainsi éviter un éventuel accident.

Oui et donc ?
Mon intervention avait pour but de faire remarquer que ton argument en faveur des pointeurs :

L'avantage du paramètre par pointeur est que lorsqu'on appelle la fonction, on sait qu'on veut modifier le paramètre par on passe l'adresse de la variable.

était douteux pour ne pas dire faux.

[mister3957]

Bref, utilise des références, sauf quand tu veux accorder à l'utilisateur de ta fonction (toi peut-être?) un paramètre nulle, que ta fonction prendra la responsabilité de tester (tout n'est qu'une question de responsabilité, utilisateur ou exécutant ?).

[Trunks]

Oui et donc ?
Mon intervention avait pour but de faire remarquer que ton argument en faveur des pointeurs :

était douteux pour ne pas dire faux.

Ok, je te l'accorde. Je disais ça en pensant aux types prédéfinis. Si on fait f(&val), on se doute qu'on veuille modifier val alors que si on fait f(val), c'est plus invisible.

Mais comme ont dit 2 autres personnes, si une valeur ne peux pas être nulle, alors autant utiliser les références.