appel constructeur sans new

Version imprimable

28/08/2006, 16h13
kacedda

appel constructeur sans new
Bonjour a tous,

Alors en fait on se dispute la dessus et du coup je sais plus coder en C++, le doute est en moi.

Code:
Code:

1 2 3 4 5 6 7 8 9 10 11 class test { public: test(); // Constructeur par defaut public: CString line1; CString line2; int nb1; long nb2; }
Dans la classe il n'y a aucune allocation dynamique, maintenant est-ce que j'ai le droit de faire ca(mon collegue pense que non):
Code:

1 2 3 test bob; bob = test();
Dans ce cas present ca marche, mais est-ce que c'est juste?
Mon pote me dit que c'est faut car on appelle un constructeur autrement que par allocation.

par contre je pense que ca c'est pas tres juste et la on est d'accord(mais si vous pouvez controler dans le cas ou on est tout les deux dans le faux).
Code:

1 2 3 4 5 test bob; bob = test(); test bloub; bloub = bob; // <-- Faux dans tout les cas
A votre avis qui a raison?
Moi je pense que c'est moi.

Merci
28/08/2006, 16h16
hegros

Dans le premier cas c'est le constructeur par recopie qui va être sollicité.(il me semble)

Dans le deuxiéme cas pareil à moins que l'operateur = soit surchargé (Même dans le premier cas si l'operateur est surchargé l'appel sera fait il me semble aussi...)
28/08/2006, 16h18
Médinoc
Il me semblait que le constructeur de copie ne serait appeler que pour:

Code:

Test bob = Test();

(et encore, le constructeur à vide serait appelé avant celui de copie)

Et que pour:
Code:

1 2 Test bob; bob = Test();
Ce serait plutôt l'opérateur d'affectation... (après deux appels du constructeur à vide).
28/08/2006, 16h35
kacedda

Ah oui! Ben justement en fait il n'y a pas de surchage de l'operateur '=' ni de constructeur par copie.
Donc ca devrait pas marcher, non?
Pour info je code sous Visual C++ 6.0. Ce pourrait-il que ce soit le compilo qui detecte et genere le constructeur ou la surcharge de l'operateur '='.

Parce que ca marche, mais pour mon collegue ca devrait pas et moi je suis perdu.
28/08/2006, 16h35
Pragmateek

Les deux cas provoquent l'appel de l'opérateur d'affectation.
28/08/2006, 17h41
Eusebe

Les compilateurs génèrent automatiquement un constructeur par copie si tu n'en déclare pas un. Et l'opération d'affectation est prédéfinie. C'est une simple recopie membre à membre des objets.
28/08/2006, 17h46
loufoque

Citation:

Ah oui! Ben justement en fait il n'y a pas de surchage de l'operateur '=' ni de constructeur par copie.
Donc ca devrait pas marcher, non?

Ils sont définis automatiquement.

Citation:

Pour info je code sous Visual C++ 6.0.

Peut-être serait-il bon d'acquérir un compilateur C++.

Citation:

A votre avis qui a raison?

À mon avis vous avez tous les deux tort et vous ne savez pas de quoi vous parlez. (confusion de construction et affectation par exemple)
28/08/2006, 18h25
b Oo
Bon pour répondre à la question :

Code:

Test bob = Test();

Ceci est interprété de la manière suivante :
Construction d'un objet temporaire et ensuite appel du constructeur par copie (non ce n'est pas l'opérateur d'affectation !).

Si le constructeur par copie n'est pas défini (comme il a été dit) le compilateur en crée un qui recopie bit à bit.
Il faut entendre par là que les valeurs sont recopiées telles quelles (donc bug si on utilise des pointeurs).
Code:

1 2 3 test bob; bob = test();
Ici un objet temporaire est crée et le compilateur appelle l'opérateur d'affection.
Pareil, s'il n'est pas définie le compilateur en crée qui recopie bit à bit.
28/08/2006, 18h29
Eusebe
Citation:
Envoyé par b Oo

Bon pour répondre à la question :

Code:

1 2 Test bob = Test();

Ceci est interprété de la manière suivante :
Construction d'un objet temporaire et ensuite appel du constructeur par copie (non ce n'est pas l'opérateur d'affectation !).
Euh, moi je pense plutôt que dans ce cas c'est le constructeur par défaut qui est appelé...
Code:

1 2 3 Test toto; Test bob = toto;
Là, par contre, c'est le contructeur par copie.
28/08/2006, 19h06
b Oo
Non Euseube, c'est sûr :
Citation:
Envoyé par Bjarne Stroustrup

In principle, copy constructors are used in simple initializations such as

Code:

1 2 3 complex x = 2 ; // create complex(2); then initialize x with it complex y = comple x (2 ,0 ); // create complex(2,0); then initialize y with it

However, the calls to the copy constructor are trivially optimized away. We could equivalently have written :

Code:

1 2 3 complex x (2 ); // initialize x by 2 complex y (2 ,0 ); // initialize y by (2,0)
Ceci est extrait de The C++ Programming Language page 271.

Citation:

Envoyé par b Oo

Non Euseube, c'est sûr

Permets moi quand même d'insister ;).

Si j'exécute le programme suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream>
 
class A
{
    public:
    // Constructeur par défaut
    A() {std::cout << "Defaut" << std::endl;}
 
    // Constructeur par copie
    A(A const &) {std::cout << "Copie" << std::endl;}
 
    // opérateur d'affectation
    A & operator=(A const &) {std::cout << "Affectation" << std::endl;}
 
};
 
 
int main()
{
    std::cout << "********************" << std::endl;
    std::cout << "A test;" << std::endl;
    std::cout << "********************" << std::endl;
    A test;
 
    std::cout << std::endl;
 
    std::cout << "********************" << std::endl;
    std::cout << "A test1 = A();" << std::endl;
    std::cout << "********************" << std::endl;
    A test1 = A();
 
    std::cout << std::endl;
 
    std::cout << "********************" << std::endl;
    std::cout << "A test2 = test1;" << std::endl;
    std::cout << "********************" << std::endl;
    A test2 = test1;
 
    std::cout << std::endl;
 
    std::cout << "********************" << std::endl;
    std::cout << "A test3;" << std::endl << "test3 = A();" << std::endl;
    std::cout << "********************" << std::endl;
    A test3;
    test3 = A();
}

J'obtiens :

Citation:

********************
A test;
********************
Defaut

********************
A test1 = A();
********************
Defaut

********************
A test2 = test1;
********************
Copie

********************
A test3;
test3 = A();
********************
Defaut
Defaut
Affectation

28/08/2006, 20h47
jeroman

Après ça dépend peut-être des compilos ? Y'en a qui respectent les normes et d'autres non.
29/08/2006, 01h24
Luc Hermitte

Citation:

Envoyé par b Oo

Si le constructeur par copie n'est pas défini (comme il a été dit) le compilateur en crée un qui recopie bit à bit.
Il faut entendre par là que les valeurs sont recopiées telles quelles (donc bug si on utilise des pointeurs).

Non. Pas "bit à bit". C'est une copie superficielle membre à membre. Si un des membres est un objet, non-POD, copy-constructible, alors son constructeur de recopie sera automatiquement appellé.
Mais effectivement, vue que la copie est juste superficielle, cela (*) ne marchera jamais correctement dès que des ressources ou des pointeurs seront de la partie.

(*) constructeur de recopie et opérateur d'affectation générés par défaut.
29/08/2006, 02h54
loufoque
Citation:

Envoyé par b Oo

Ceci est interprété de la manière suivante :
Construction d'un objet temporaire et ensuite appel du constructeur par copie

On notera néanmoins que le compilateur est autorisé à éviter cette copie.

Eusebe, tu as apparemment mal compris les propos de b Oo et en plus tu dis des trucs parfaitement faux qu'on a déjà expliqués dix fois dans le sujet.
Non,
Code:

1 2 Test toto; toto = Test();
n'appelle pas le constructeur de copie
29/08/2006, 09h21
Eusebe
Citation:
Envoyé par loufoque

Eusebe, tu as apparemment mal compris les propos de b Oo et en plus tu dis des trucs parfaitement faux qu'on a déjà expliqués dix fois dans le sujet.
Non,

Code:

1 2 Test toto; toto = Test();

n'appelle pas le constructeur de copie
Loufoque, tu ferais bien de mieux lire les messages avant de poster tes commentaires toujours aussi désagréables sur la forme : je n'ai jamais dis ça...
29/08/2006, 10h28
kacedda

Ok! Merci pour les infos.
Donc apparement le compilo me cree un constructeur par copie par defaut. Et ca marche uniquement parce que ma classe est composé d'objet simple.

Donc j'en deduis que c'est assez dangereux(cas ou c'est des pointeurs) mon collegue a donc raison.

Par contre au niveau securite que vaut-il mieux faire:
- surcharger l'operateur '=';
ou
- creer le constructeur par copie.
Je suis d'accord que dans l'absolu vaut mieux faire les deux mais bon dans le cas de variables membres de type pointeur perso je pense qu'il vaut mieux surcharger l'operateur '=', mais je sais pas si ca revient au meme.

A+

Pour moi, le mieux est, quand c'est possible, de surcharger l'opérateur '=' et de l'appeler dans le constructeur de copie.
Code:

1 2 3 4 5 6 7 8 9 10 class CUneClasse { public: CUneClasse( paramètres ); inline CUneClasse(CUneClasse const &rcSource) { *this = rcSource }; CUneClasse & operator= (CUneClasse const &); // + destructeur, virtuel ou non };
Code:

1 2 3 4 5 6 7 8 9 CUneClasse & CUneClasse::operator= (CUneClasse const &rcSource) { //anti-auto-affectation if(&rcSource == this) return *this; // Opérations de copie //... return *this; }
Edit: La condition pour cela, c'est que l'opérateur '=' redéfini fonctionne sans problème sur un objet non-initialisé. Sinon, tu devras soit initialiser dans le constructeur de copie avant d'appeler l'opérateur '=', soit redéfinir complètement le constructeur de copie.

29/08/2006, 10h45
Eusebe

Il faut que tu redéfinisse les deux (et en général également le destructeur).

En fonction de ton code, l'un ou l'autre peuvent être appelés. Si tu n'en redéfinis qu'un, tu n'est pas à l'abri que l'autre soit utilisé... et donc entraîne des incohérences.

En règle générale, si tu dois redéfinir le constructeur par copie, l'opérateur d'affectation ou le destructeur, il FAUT que tu redéfinisse ces éléments.

Edit : +1 pour la solution de Médinoc
29/08/2006, 10h51
kacedda

Ok, merci!
Dans le doute je ferai les deux!

Code:

1 2 inline CUneClasse(CUneClasse const &rcSource) { *this = rcSource };
"inline" n'est il pas redondant dans ce cas?

29/08/2006, 11h47
Laurent Gomila
Citation:

Pour moi, le mieux est, quand c'est possible, de surcharger l'opérateur '=' et de l'appeler dans le constructeur de copie

Plutôt l'inverse. Faire une petite recherche sur ce forum, l'opérateur = qui utilise le constructeur par copie est souvent donné.
Citation:
Code:

1 2 3 //anti-auto-affectation if(&rcSource == this) return *this;
Voir la FAQ à ce propos, et également le code que je cite ci-dessus.

On va intégrer une grosse Q/R pour l'opérateur = dans la prochaine MAJ de la FAQ, mais en attendant... :aie:
29/08/2006, 12h18
Médinoc

Citation:

Envoyé par Laurent Gomila

Plutôt l'inverse. Faire une petite recherche sur ce forum, l'opérateur = qui utilise le constructeur par copie est souvent donné.

??
Je n'arrive même pas à voir comment on peut faire cela, puisqu'on n'est pas supposé pouvoir utiliser un constructeur sur un objet existant...

En trichant sur le fait qu'on puisse quand même ? (placement new, etc.)

Je parlais de ce genre d'opérateur d'affectation, qui utilise le constructeur par copie pour dupliquer et le destructeur pour... détruire :
Code:

1 2 3 4 5 6 7 8 Classe& Classe::operator =(const Classe& Other) { Classe Temp(Other); // Copie Temp.swap(*this); // Echange vieilles <-> nouvelles données return *this; } // destruction des vieilles données avec la destruction de Temp
Exception-safe, pas de problème d'auto-affectation, .... le blah blah habituel.

29/08/2006, 22h32
Médinoc

Ah, OK...
L'idée même d'une méthode swap() n'était pas encore entrée dans ma tête, donc je ne pouvais pas savoir...

D'ailleurs, pour moi, cet opérateur d'affectation repose même plus sur la méthode swap() que sur le constructeur de copie...
30/08/2006, 20h30
Luc Hermitte

C'est surtout que le test pour prévenir de l'auto-affectation est un contre-idiome qui date du temps où les exceptions n'étaient pas comprises -- et où les gens devaient avoir peur des variables temporaires. :?

Avec le RAII, cf le raffinement de la règle de 3 qui descend à 2 (le lien est donné dans l'article de FAQ sur le RAII.), il n'est plus obligatoire de définir le destructeur bien qu'il puisse être requis d'expliciter les opérations de copie. De plus, il n'est pas rare de définir le destructeur et d'interdire les opérations de copie.

Citation:

Envoyé par kaceda

Donc apparement le compilo me cree un constructeur par copie par defaut. Et ca marche uniquement parce que ma classe est composé d'objet simple.

C'est acceptable uniquement si tes données membres ont une sémantique de copie. Il y a un petit côté transitif. Si toutes les données membres d'une classe sont copiables, alors la classe devient implicitement copiable.
01/09/2006, 13h46
Gnux

Citation:

Envoyé par Eusebe

Loufoque, tu ferais bien de mieux lire les messages avant de poster tes commentaires toujours aussi désagréables sur la forme : je n'ai jamais dis ça...

+1, c'était encore une brillante intervention de loufoque qui n'a jamais aussi bien porté son nom.
Tu connais des choses loufoque, alors fais un effort mets en adéquation la connaissance du fond avec de l'intelligence dans la forme sinon...
01/09/2006, 20h01
loufoque

Citation:

+1, c'était encore une brillante intervention de loufoque qui n'a jamais aussi bien porté son nom.
Tu connais des choses loufoque, alors fais un effort mets en adéquation la connaissance du fond avec de l'intelligence dans la forme sinon...

Bon ça va... J'avais mal lu.
Je fais une connerie une fois et je me prends plein la gueule à ce que je vois.
01/09/2006, 21h41
Gnux

Citation:

Envoyé par loufoque

Bon ça va... J'avais mal lu.
Je fais une connerie une fois et je me prends plein la gueule à ce que je vois.

T'as tout compris...C'est dommage que tu te comportes ainsi je trouve. Ca ne fait pas honneur à ce que tu sais...