Question sur le passage par référence

Bonjour,

Je me pose encore des questions sur le passage par référence, notamment après avoir lu une explication donnée par Claude Delennoy dans l'un de ses livres d'exercices. Après avoir rappelé le rôle du passage par référence, il ajoute:
"Toutefois, si l'argument muet est, de surcroît, déclaré avec l'attribut const, la fonction reçoit quand même une copie de l'argument effectif correspondant, lequel peut alors être une constante ou une expression d'un type susceptible d'être converti dans le type attendu."

Ma question est la suivante: Y a t'-il toujours copie de l'argument effectif dans le cas où l'attribut const est ajouté ? Ou bien y a t'-il copie uniquement dans les deux cas cités ci-dessus (ce que je croyais avoir compris avant) ?

Par ailleurs, dans tous les cas où il y a effectivement copie, le code ci-dessous correspondant à une fonction membre me pose un problème:

Code:

---

1 2 3 4 5 6 7 8 9

String& String::operator=(const String & rhs) { if (this == &rhs) return *this; . . . }

---

En effet, s'il y a copie, l'objet créé aura toujours une adresse différente du pointeur this. Donc, même si l'argument rhs fait référence au même objet que celui pointé par this, le test ne peut pas fonctionner !

Si vous pouviez m'indiquer mon erreur, je vous en serait fort reconnaissant.

Salut,

Il l'exprime assez mal, mais ce qu'il tente d'exprimer c'est que, si tu déclare un argument de fonction sous la forme d'une référence constante, il est possible de passer une variable temporaire anonyme, s'il existe un constructeur pour le type attendu capable de servir d'opérateur de conversion.

Par exemple, il existe un constructeur pour la classe std::string qui prend comme argument un char const * (une chaine "C style en fait :D)

Tu peux donc déclarer une chaine str sous la forme de

Code:

---

std::string str("Salut Koala");

---

mais ce constructeur agit comme opérateur de conversion d'un char const * en std::string, comme on peut le remarquer avec le code

Code:

---

1 2	std::string str; str="Salut toi";

---

car dans ce deuxième exemple "Salut toi" n'est en réalité... pas un std::string mais... un char const *.

Si tu as une fonction prenant comme argument une référence constante sur une std::string proche de

Code:

---

void foo(std::string const & truc);

---

tu peux, fatalement, envisager de l'invoquer sous une forme proche de

Code:

---

1 2	std::string str("Salut Koala"); foo(str);

---

et, comme il s'agit d'une référence, il n'y aura pas de copie de l'objet nommé str.

Mais tu peux aussi invoquer cette fonction sous la forme de

Code:

---

foo("Salut toi");

---

Et, dans ce cas, le constructeur de std::string prenant un char const * comme paramètre agira encore une fois comme un opérateur de conversion de char const * en std::string, mais, comme "Salut toi" n'est pas une std::string et que... c'est ce qu'attend la fonction foo, il y a création de ce que l'on appelle une "variable temporaire anonyme" de type... std::string.

En effet, cette variable n'existera que... durant l'exécution de foo, ce qui la rend... temporaire et, comme il n'y a aucun identifiant qui permette d'utiliser cette variable en dehors de foo, il s'agit bel et bien d'une fonction anonyme ;)

Tout cela pour dire que, normalement, s'il existe effectivement un objet du type attendu, il n'y aura ni copie ni création d'objet, mais que, dans certaines circonstances (lorsque ce qui est passé en argument à la fonction n'est pas du type attendu mais qu'il existe effectivement un constructeur pouvant faire office d'opérateur de conversion), il peut y avoir création d'un objet.

Merci d'avoir pris le temps de m'expliquer en détail ce problème. Ton explication est très claire. ;)