Discussion :

[maiza_med]

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 ?

[foetus]

Je vois 2 réponses

• 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.

[ternel]

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 :

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

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 :

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

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

[Jimmy91]

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 !

[jblecanard]

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.

[Jimmy91]

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.

[Médinoc]

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.

[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.