références...

bonjour,
j'aimerais savoir comment ca marche les références.
pouvez-vous m'expliquer en détail svp
merci

On n'est pas vraiment là pour ça ; les bouquins / cours par contre, oui. Par contre si tu as un problème plus précis avec l'utilisation des références, on se fera un plaisir de te l'expliquer.

:faq:
http://c.developpez.com/faq/cpp/?page=references

bonjour,
voici mon probleme :

pourquoi lors d'un retour de référence on ceci : ??

Code:

---

1 2 3 4 5

const Date& getdate(int n) { return birthdays[n-1]; }

---

normalement on doit retourner qqch comme : &variable_de_ref puisque l'on retourne une référence et non un contenu

merci d'avance.[/code]

Salut

J'ai fusionné les posts, merci de garder un seul sujet pour un même problème.

En ce qui concerne ta question, &var renverrait l'adresse de var, chose qu'il faudrait faire si l'on retournait un pointeur. Or une référence se distingue justement des pointeurs par cet apsect : aucune syntaxe supplémentaire n'est nécessaire pour les utiliser.

Relis bien la FAQ, tout ceci est expliqué en détail :wink:

Parce que le C++ supporte le passage par référence. Il se charge de passer/renvoyer une référence au lieu d'une copie.
Le C ne supporte que le passage par valeur, donc tu dois toi même renvoyer l'adresse de l'objet, qui est transmise par valeur...

ok et autre et derniere question sur ce sujet :

une fois que l'on a mis donc la fonction qui retourne la référence,

dans la fonction main, doit-on la stoquer comme ceci :

int a=fct(); (ce que j'ai vu dans un code) ou alors comme ceci : int &a=fct(); (ce qui me semble plus logique)

et pourquoi ?

Les 2 vont fonctionner, mais le résultat ne sera pas pareil. fct() te renvoie un objet par référence. Maintenant, tu vas récupérer cet objet.
si tu mets

Code:

---

int a=fct();

---

tu va en faire une copie, donc une copie de l'objet référencé (renvoyé parréférence). Si tu mets

Code:

---

int & a=fct();

---

tu va conserver la référence renvoyée. La différence:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

int & fct() { // attention à ne pas renvoyer un objet local (temporaire) // en référence, car tu renverrais une référence vers un objet // détruit dès qu'on sort de fct() static int n = 0; return n; }   int i = fct(); i = 10; cout << i << '\n'; // affiche 10 cout << fct() << '\n'; // affiche 0 car on a modifié une copie   int & r = fct(); r = 10; cout << r << '\n'; // affiche 10 cout << fct() << '\n'; // affiche 10 car on a modifié n via la référence...

---

je pense avoir saisie meme si quelque chose est encore un peu flou :)

pourquoi peut on faire l'affectation suivante :

Code:

---

1 2	int a=fct();

---

alors que l'on retourne une référence !!!
a n'est pas déclarée comme une référence a la difference de ceci :

Code:

---

1 2	int &a=b; par exemple

---

en effet, => int & fct();

parce que une référence reste une variable copiable, donc dans le cas de

Code:

---

int a = fct();

---

c'est une copie du retour de fct() qui est stockée dans a ;)

Conceptuellement, il faut considérer que la fonction renvoie un objet.
Lorsque tu écris

Code:

---

int a = fct();

---

c'est comme si tu écrivais

Code:

---

int a = UnObjet ;

---

et dans ce cas , UnObjet étant situé à droite du signe =, ceci s'interprète, comme d'habitude, comme la copie de la valeur de l'objet UnObjet dans a :
il y a copie de l'objet retourné par la fonction dans l'objet a
C'est pour cela, qu'on pourrait écrire :

Code:

---

fct() = 10;

---

qui donnerait la valeur 10 à l'objet retourné par fct().
Lorsque tu écris

Code:

---

int & a = fct();

---

tu donne un nom (un alias) a à l'objet retourné par la fonction. Autrement dit, a est un nom pour l'objet retourné, il ne désigne pas un AUTRE objet comme dans le premier cas
Relis attentivement les explications du post d' Aurelien.Regat-Barrel

oui mais dans ce cas derniere ambiguité :

quelle différence y a til entre les deux choses suivantes :

Code:

---

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

int & fct() { return a; }   int main() { int a=fct(); ... return 0; }

---

et

Code:

---

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

int fct() { return a; }   int main() { int a=fct(); ... return 0; }

---

autrement dis => pourquoi déclarer une fonction qui renvoie une référence si on copie juste la variable qu'elle retourne et non la référence (voir main())

ça permet de modifier la valeur renvoyée par la fonction, ça peut être très utile dans certains cas (pour l'opérateur [] par exemple), ça permet aussi (quand c'est un objet qui est renvoyé) de faire des appels chainés, sans copie d'objets... par exemple : voir la FAQ, l'article sur l'idiome du paramètre nommé (si mes souvenirs sont bons)

Code:

---

1 2 3 4

int & fct() { return a; }

---

Comme l'a explicitement dit Aurélien, j'espère que ton a n'est pas une variable locale, sinon c'est foutu.

Code:

---

1 2 3 4 5 6

int & fct() { int a ; .... return a; BOOM }

---

Code:

---

1 2 3 4 5

int & fct(int a) { .... return a; BOOM }

---

Code:

---

1 2 3 4 5

int & fct(int &a) { .... return a; OK }

---

Sinon, les explications fournies répondent à ta question , je crois.

La FAQ me parrait assez claire pourtant:

Citation:

---

Une référence est un alias, un nom alternatif pour un objet. Le principe à retenir est que tout se passe comme si c'était l'objet lui-même et non une référence sur lui.

---

Code:

---

1 2 3 4

int & fct() { return a; }

---

c'est comme si tu renvoyais a. Sinon tu renvoies une copie. L'intérrêt peut donc aussi être au niveau des optimisations, pour économiser des recopies (bon sur un int c'est inutile), c'est le but des références constantes.