Discussion :

[NiamorH]

Bonjour,

ma question est plutôt une demande de précision.

J'ai un constructeur par copie qui prend (const MaClasse&) en parametre.
J'ai un operateur+ qui renvoie un const MaClasse.

J'ai une erreur de compilation ici :

Code :

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

C c3( c1+c2 )

La solution j'imagine est de faire un constructeur par copie sans référence?
Dans ce cas, le compilateur pourra-t-il éviter la copie inutile ? Comment le vérifier ?

[Laurent Gomila]

Un temporaire (comme celui renvoyé par c1 + c2) peut tout à fait être pris en paramètre en tant que référence constante. Il faudrait nous montrer les prototypes de ton constructeur par copie ainsi que de ton opérateur +.

[NiamorH]

Effectivement j'ai mal fait mon test, l'erreur était ailleurs.
Au passage, un constructeur par copie sans référence est interdit ce qui semble logique après coup.

Par contre, l'exemple mis à part, je me demande toujours si il y a une façon de voir lorsqu'un compilateur a évité une copie?

[Alp]

Code :

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

1
2
3
4
Foo(const Foo& f) /*: tu initialises les attributs */
{
std::cout << "Foo(const Foo&) appelé" << std::endl
}

[NiamorH]

Le fait de mettre du code autre que de l'initialisation dans un constructeur par copie ne va-t-il pas 'forcer' le compilateur à l'appeller justement ?

[Alp]

Non. Je ne pense pas. Il y a des situations bien précises dans lesquelles un constructeur de copie est appelé. La norme les liste exhaustivement, il me semble.

Ne les connaissant pas toutes, je te suggère d'utiliser l'affichage de messages pour connaitre les moments où il est appelé.
Une façon plus ludique est de te lister plusieurs situations où il serait susceptible d'être appelé, incrémenter un compteur dans le constructeur de copie de 1 par appel, et voir la valeur de ce compteur à la fin de ton code. Et là tu réfléchis à quelle instruction appelle le constructeur de copie.
Le plus rapide et efficace demeurant cependant une recherche efficace sur de bons sites de programmation, entre autres sur ce forum, où quelqu'un a déjà du lister les situations où le constructeur de copie est appelé.

[Laurent Gomila]

Au passage, un constructeur par copie sans référence est interdit

Pas spécialement non. C'est notamment utilisé pour faire du déplacement (ce que fait std::auto_ptr : lorsqu'il est copié il perd la responsabilité du pointeur).

Par contre, l'exemple mis à part, je me demande toujours si il y a une façon de voir lorsqu'un compilateur a évité une copie?

Je suppose que le meilleur moyen est de connaître les règles d'optimisation décrites dans la norme.

Le fait de mettre du code autre que de l'initialisation dans un constructeur par copie ne va-t-il pas 'forcer' le compilateur à l'appeller justement ?

Possible, là encore il faudrait voir ce que dit la norme (peut-être que l'élimination de la copie n'est possible que si le constructeur par copie est trivial).

[NiamorH]

Citation:
Au passage, un constructeur par copie sans référence est interdit

Pas spécialement non. C'est notamment utilisé pour faire du déplacement (ce que fait std::auto_ptr : lorsqu'il est copié il perd la responsabilité du pointeur).

Et bien mon compilateur m'a rappellé à l'ordre lorsque j'ai voulu écrire le constructeur par copie sans le &.

Et ça semble logique, car si on ne passe la classe que par valeur, alors une première copie doit être faite, ce qui va appeller le constructeur par copie, et c'est le cercle sans fin. Je ne vois pas trop comment celà se pourrait autrement.

[Alp]

En fin de compte il me semble que je me sois emporté...
Cela me dit quelque chose, le cas du constructeur de copie non trivial. En effet peut-être que cela a des incidences ...
Probablement faux un bout de ce que j'ai dit plus haut...

[Laurent Gomila]

Et bien mon compilateur m'a rappellé à l'ordre lorsque j'ai voulu écrire le constructeur par copie sans le &.

Oups j'avais mal lu... J'avais cru voir "un constructeur par copie qui prend une référence".

[Jean-Marc.Bourguet]

Un constructeur de copie prend nécessairement son premier paramètre par référence (pas nécessairement const, et potentiellement volatile), les autres ayant une valeur par défaut.

Il est appelé à chaque fois qu'un objet est construit à partir d'un autre du même type (ou d'un type dérivé), mais il y a des cas où le compilateur peut ne pas faire de copie (que cette supression soit détectable par un programme conforme ou pas) et réutiliser en fait l'objet:
- quand l'objet copié est un temporaire
- quand la copie est utilisée pour bâtir le résultat d'une fonction, même si l'objet est nommé.

[NiamorH]

- quand la copie est utilisée pour bâtir le résultat d'une fonction, même si l'objet est nommé.

Du style:

Code :

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

1
2
A a( 34 );
return a;

Celui là je m'en doutais sinon tout l'article sur la métaprog s'effondre

Code :

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

- quand l'objet copié est un temporaire

Je pensais que c'était la même chose, quelle est la différence ?

Donc à priori le compilateur ne se préoccupe pas de ce qu'il y a dans le constructeur par copie pour déterminer l'appel ou non de celui-ci.