Version imprimable
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 :
La solution j'imagine est de faire un constructeur par copie sans référence?Code:C c3( c1+c2 )
Dans ce cas, le compilateur pourra-t-il éviter la copie inutile ? Comment le vérifier ?
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 +.
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?
Code:
2
3
4
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 ?
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é.
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).Citation:
Au passage, un constructeur par copie sans référence est interdit
Je suppose que le meilleur moyen est de connaître les règles d'optimisation décrites dans la norme.Citation:
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?
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).Citation:
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 ?
Et bien mon compilateur m'a rappellé à l'ordre lorsque j'ai voulu écrire le constructeur par copie sans le &.Citation:
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).Citation:
Citation:
Au passage, un constructeur par copie sans référence est interdit
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.
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...
Oups j'avais mal lu... J'avais cru voir "un constructeur par copie qui prend une référence".Citation:
Et bien mon compilateur m'a rappellé à l'ordre lorsque j'ai voulu écrire le constructeur par copie sans le &.
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é.
Du style:Citation:
Envoyé par Jean-Marc.Bourguet
Celui là je m'en doutais sinon tout l'article sur la métaprog s'effondre ;)Code:
2
Je pensais que c'était la même chose, quelle est la différence ?Code:- quand l'objet copié est un temporaire
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.