Passage par valeur & passage par référence

Salut à tous,

j'aimerais bien savoir dans quel cas on est obligé d'utiliser le passage par référence et dans quel cas on utilise le passage par valeur ?

Je vois 2 réponses :mrgreen:

• Passage par valeur pour des "Plain Old Data" (POD), par référence pour les classes
• Passage par valeur pour les paramètres d'entrée (pas de modification) et par référence pour les paramètres de sortie (*) (modification, récupération de valeur)

* -> Comme l'a dit leternel, on peut préciser const pour ne pas modifier une référence.

La référence ne copie pas l'objet.

Si tu as un objet de 8Mo, tu préfères ne pas le copier pour le passer à une fonction.
La solution, c'est le passage par référence (constante : T const&) (ou en C, par pointeur constant)

L'autre avantage de la référence, c'est que si elle n'est pas constante (T &), tu peux modifier l'objet utilisé pour l'appel de la fonction.

C'est comme cela que fonctionne cin >> variable.
Il s'agit de l'appel de la fonction operator>>(istream&, T&) avec pour argument cin et variable.


Il y a en fait trois modes de passages de paramètres:

1. par valeur
2. par référence constante
3. par référence modifiante

A cela s'ajoute le problème du pointeur, mais en C++, tu ne l'utiliseras pas sans une bonne raison.
Un pointeur est plus ou moins comme une référence. (T const& correspondrait à T const&, et T * à T &).

Le plus efficace est le passage par référence constante, dès que la variable est plus grosse qu'une référence (c'est à dire pour quasiment tout objet)
Ca devrait être ton choix par défaut pour les classes.

Les autres modes répondent à d'autres critères.

Le passage par valeur est satisfaisant quand la variable est petite (un type primitif, ou une std::pair<int, int>, par exemple).
Il est aussi intéressant quand on veut explicitement faire une copie de l'argument.
par exemple, une fonction pourrait prendre un iterateur par copie, pour modifier cette copie en interne, sans modifier l'argument.

par exemple std::distance pourrait être implémenté ainsi:

Code:

---

1 2 3 4 5

"unsigned int" distance( InputIt first, InputIt const& last) { unsigned int d = 0; while ((first++)!=last) d++; return d; }

---

Comme les compilateurs peuvent faire ce qu'ils veulent tant que "tout se passe comme si" ils avaient fait comme tu demandes, tu peux même toujours passer une référence constante plutot qu'une copie.

int f(int i) {return i;} et int f(int const& i) {return i;} devrait être compilées de la même manière.
Je préfère cependant la première car elle est plus légère à lire.

La référence modifiante correspond en général à une valeur de retour ou un contexte à modifier.
si je reprends les operateurs >> de cin, tu as la forme complete suivante:

Code:

---

1 2 3 4

std::istream& operator>>(std istream& stream, Type & variable) { //...modifier variable avec cin return stream; }

---

Salut,

Lorsqu'un objet est passé par référence à une fonction, elle travaille directement sur l'objet qui a lui a été fourni : tous les traitements que la fonction fait subir à l'objet seront effectifs même après la fin de ta fonction.

Lorsqu'un objet est passé par valeur à une fonction, l'objet est copié au préalable et c'est sur cette copie que ta fonction va travailler. En conséquence, l'objet que tu passes à ta fonction ne sera pas modifié par tes traitements.

En gros, si on résume dans quels cas tu dois utiliser l'une ou l'autre des techniques :

Passage par référence :

• Tu veux éviter de recopier l'objet passé en argument (ce qui peut altérer les performances du programme en fonction de la taille de l'objet)
• Tu veux que l'objet passé en argument soit modifié directement par les traitements de ta fonction

Passage par copie :

• Tu ne veux pas que l'objet passé en argument soit modifié

J'espère avoir été clair et ne pas avoir dit de bêtise !

Citation:

---

Envoyé par Jimmy91

Passage par copie :

• Tu ne veux pas que l'objet passé en argument soit modifié

---

Ca c'est une bêtise, pour que l'objet ne soit pas modifié, c'est const qu'on utilise.

Aujourd'hui, le passage par valeur en C++ moderne ne se justifie dans presque aucun cas. Il est tolérable pour les types primitifs. Sinon, j'applique les règles suivantes :

Passage par référence (l-value-reference):

• non constante si l'appelé doit modifier ou stocker une référence vers l'objet
• constante dans tous les autres cas

Passage par r-value-reference quand la propriété de l'objet doit être confiée à l'appelé.

Le fait que la fonction appelée copie l'objet passé en argument est toujours possible avec une référence constante si l'objet est copiable, et devrait rester un détail d'implémentation. Si tu dois retenir une chose, une seule : exit le passage par valeur sauf pour les types primitifs de petite taille.

Citation:

---

Envoyé par jblecanard

Ca c'est une bêtise, pour que l'objet ne soit pas modifié, c'est const qu'on utilise.

---

Merci pour cette correction ! Au temps pour moi, je n'avais pas pensé au passage par référence constante.

Le passage par valeur est aussi utile dans une implémentation de l'idiome copy-and-swap (où une copie est de toute façon nécessaire), car il permet d'éviter une copie inutile dans certains cas.

Le passage par valeur sur autre chose qu'un type natif ou pointeur, tu devrais en avoir très peu, voire aucun.
Le seul moment où tu passeras par valeur c'est justement parce que ta fonction a besoin de modifier une copie du paramètre. Et même dans ce cas, il sera souvent plus clair pour tous de déclarer le paramètre const& et faire une copie effectivement à l'intérieur.

Citation:

---

Envoyé par Bousk

Le passage par valeur sur autre chose qu'un type natif ou pointeur, tu devrais en avoir très peu, voire aucun.
Le seul moment où tu passeras par valeur c'est justement parce que ta fonction a besoin de modifier une copie du paramètre. Et même dans ce cas, il sera souvent plus clair pour tous de déclarer le paramètre const& et faire une copie effectivement à l'intérieur.

---

Si par exemple on a :

Code:

---

1 2 3 4

void incr(int &a) //ça marchera jamais si la variable a n'est pas passée en référence lors de l'appel { a++; }

---

hors que dans ce qui suit (la fonction pgcd)

Code:

---

1 2 3 4 5 6 7 8 9 10

int pgcd(int a, int b) //aucun paramètre n'est passé en référence et ça marche lors de l'appel de la fonction en main() { int r; while (b != 0) { r = a%b ; a = b; b = r; } return a ; }

---

Et donc, en quoi les propos de bousk contredisent-t-ils tes examples maiza_med ?

Citation:

---

Envoyé par jblecanard

Et donc, en quoi les propos de bousk contredisent-t-ils tes examples maiza_med ?

---

J'voulais juste savoir pourquoi ça a marché pour la fonction PGCD(sans utiliser le &) pourtant notre fonction à modifier les paramètres ???

Non, elle modifie une copie des paramètres. Dans l'appelant, les valeurs passées pour a et b n'ont pas changé.

Citation:

---

Envoyé par Médinoc

Non, elle modifie une copie des paramètres. Dans l'appelant, les valeurs passées pour a et b n'ont pas changé.

---

En faite j'ai comparé les changements des paramètres de la fonction pgcd avec la fonction permut où le contenu sera changé :

Code:

---

1 2 3 4 5 6

void permut(int &x, int &y) { int z; z=y; y=x; x=z; }

---

Citation:

---

Envoyé par maiza_med

Et j'ai constaté aussi que le passage par référence est utilisé beaucoup plus pour les procédure (void) dont on a pas un résultat (return) ????

---

Mis à part que tu confonds tout et que ça n'a aucun rapport, je ne vois pas où tu espères en venir avec tes "exemples" ou cette phrase. :weird:
Passer les paramètres par références pour les modifier, c'est un peu la base... et je vois pas ce que le type de retour vient faire là-dedans ?
Tu veux modifier un paramètre ? Tu utilises une référence ou un pointeur. Tu veux retourner une valeur ? Tu retournes une valeur... (captain obvious inside)
Tu veux faire les 2 ? Fais les 2! Ce sont juste 2 choses complètement orthogonales. Exemple, au hasard, une fonction bool Find(T* p).
En plus ce terme de procédure, ça fait un moment que je l'ai pas entendu, surtout en C++. :calim2:

Btw, la copie ou const& est également le seul moyen de passer des litéraux à une fonction. Là où une référence exigera d'utiliser une vraie variable.