Discussion :

[Marc_3]

Bonjour
Je saisis pas tout a fait le role et l'utilisation d'un constructeur par copie.
On s'en sert pour faire des copies et eventuellement des copies surchargee d'objet. Voila jusque la ca va a peut pres mais j'aimerai savoir ce qui se passe au niveau en dessous apres un return ou a la fermeture d'un bloc etc.
Est_ce quelqu'un peut me dire ou trouver des info ou un tuto a ce sujet

D'avance merci

Marc_3

[xxiemeciel]

Salut,

ben le constructeur par copy reste un constructeur donc tout depend de la maniere dont tu as declaré ta copie :

Code :

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

1
2
3
4
 
Objet obj;
 
Objet * copie = new Objet( &obj );

ou bien

Code :

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

1
2
 
Objet copie( &obj );

XXiemeciel

[Luc Hermitte]

Un constructeur de copie est un constructeur particulier à la signature bien précise. Il prend en entrée soit une référence constante (forme majoritaire), soit une référence vers un objet du même type.
Soit:

Code :

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

1
2
3
4
struct T
    T(T const& rhs); // forme principale qui déclare ne pas modifier rhs
    T(T & rhs); // forme qui déclare s'autoriser à modifier rhs
};

(Corrolaire: cela ne prendra jamais un pointeur en paramètre)

Les constructeurs de recopie sont utilisé pour construire un nouvel objet à partir de celui passé en paramètre -- en supposant qu'il n'y a pas d'héritage.

(je me restreins à la sémantique de valeur et de fait ignore les problèmes d'héritage. Chercher sur le forum des posts de la semaine dernière sur le comment ils doivent être utilisés lorsque l'héritage public est de la partie)
Typiquement, ils seront appelés dans les situations suivantes:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
...{
    T toto;
    T titi = toto; // ici
    T tata(toto); // ici aussi, autre écriture globalement équivalente
 
    toto = titi; // pas ici, il s'agit d'une affectation qui repose cette fois
       // sur l'opérateur d'affectation.
 
    T & ref = toto; // pas ici, c'est une référence
    T * ptr = &toto; // pas ici, pointeur, rien à voir avec le smilblick
    T *p2 = &tata; // toujours pas
 
    *ptr = *p2; // pas ici, c'est une affectation
    ptr = &titi; // rien à voir, ptr pointe maintenant sur titi
 
    T tutu(*ptr); // ici, on construit à partir du T pointé par ptr.
}
...
void f(T t); // ici une copie est réalisé => constructeur de recopie utilisé
void f2(T &t); // pas ici
void f3(T const& t); // ici non plus
 
T g(); // ici, une copie sera réalisée au moment du return
  // sauf optimisations parfois réalisées par certains compilos

[Marc_3]

merci pour les reponses cela m'aide a rentrer dans le sujet, je suis particulierement interresse par la derniere variante

Cad celle-ci et ses implications

Code :

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

1
2
3
 
T g(); // ici, une copie sera réalisée au moment du return
  // sauf optimisations parfois réalisées par certains compilos

Si vous avez des complements la dessus je serai ravi de bucher ca.

Encore merci et
D'avance merci

marc_3

[Luc Hermitte]

Ce n'est pas une variante. C'est une signature de fonction renvoyant un T par valeur.
Pour avoir plus d'info : google -> "return value optimization" ou "RVO". Son support varie d'un compilateur à l'autre.