appel constructeur sans new

**kacedda** · 28/08/2006, 16h13

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 :

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

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 :

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

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 :

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

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

**hegros** · 28/08/2006, 16h16

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...)

**Médinoc** · 28/08/2006, 16h18

Il me semblait que le constructeur de copie ne serait appeler que pour:

Code :

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

Test bob = Test();

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

Et que pour:

Code :

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

1
2
Test bob;
bob = Test();

Ce serait plutôt l'opérateur d'affectation... (après deux appels du constructeur à vide).

**kacedda** · 28/08/2006, 16h35

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.

**Pragmateek** · 28/08/2006, 16h35

Les deux cas provoquent l'appel de l'opérateur d'affectation.

**Eusebe** · 28/08/2006, 17h41

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.

**loufoque** · 28/08/2006, 17h46

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.

Pour info je code sous Visual C++ 6.0.

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

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)

**b Oo** · 28/08/2006, 18h25

Bon pour répondre à la question :

Code :

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

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 :

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

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.

**Eusebe** · 28/08/2006, 18h29

Envoyé par b Oo

Bon pour répondre à la question :

Code :

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

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 :

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

1
2
3
 
Test toto;
Test bob = toto;

Là, par contre, c'est le contructeur par copie.

**b Oo** · 28/08/2006, 19h06

Non Euseube, c'est sûr :

Envoyé par Bjarne Stroustrup

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

Code :

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

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 :

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

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.

**Eusebe** · 28/08/2006, 19h59

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 :

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
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 :

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

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

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

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

**jeroman** · 28/08/2006, 20h47

Après ça dépend peut-être des compilos ? Y'en a qui respectent les normes et d'autres non.

**Luc Hermitte** · 29/08/2006, 01h24

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.

**loufoque** · 29/08/2006, 02h54

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 :

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

1
2
Test toto;
toto = Test();

n'appelle pas le constructeur de copie

**Eusebe** · 29/08/2006, 09h21

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 :

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

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...

**kacedda** · 29/08/2006, 10h28

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+

**Médinoc** · 29/08/2006, 10h43

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

Code :

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

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 :

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

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.

**Eusebe** · 29/08/2006, 10h45

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

**kacedda** · 29/08/2006, 10h51

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

**Pragmateek** · 29/08/2006, 11h31

Code :

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

1
2
inline CUneClasse(CUneClasse const &rcSource)
		{ *this = rcSource };

"inline" n'est il pas redondant dans ce cas?

appel constructeur sans new

C++

Discussions similaires

Partager

Partager