Le constructeur de copie

Sujet résolu

14 juin 2007 à 21:20:15

Bonsoir,

Mon problème portesur la partie concernant le constructeur de copie du cours de M@théo21.
En effet, je ne comprend pas cette ligne de code :

m_arme = new Arme();

ou si vous préférez :

Personnage::Personnage(const Personnage &personnageACopier)
{
m_vie = personnageACopier.m_vie;
m_mana = personnageACopier.m_mana;
m_arme = new Arme();
}

meme si par la suite on remplace cette ligne par :

m_arme = new Arme(*(personnageACopier.m_arme));

Mais ce n'est pas ici qu'est mon problème, ni dans le new d'ailleurs, mais plutôt ici :

Arme();

Depuis quand on met des parenthèses après le nom de la classe ?
De plus ces parenthèses contiennent par la suite, comme je l'ai dit plus haut,

*(personnageACopier.m_arme)

soit une référence.

On appel en réalité le constructeur de copie de la classe Arme...
Moi j'ai appris que le constructeur de copie s'appelait dans ce cas là par exemple :

Personnage David(Goliath);

Est-ce une particularité du new que d'autoriser l'ajout de parenthèses, et l'appel du constructeur de copie apres la classe ?
Un peu comme quand on écrit (une exception en somme):

new int[10];

Ou est-ce que je n'ai rien compris

?

D'avance merci !

psychoh13

14 juin 2007 à 22:28:50

Je crois que tu n'as rien compris

En C++, le nom de la classe suivit de parenthèse est un constructeur, c'est d'ailleurs comme ça qu'on les reconnaît, et le destructeur c'est pareil, sauf qu'on ajoute le tilde "~" devant. New, il demande un constructeur lui, donc on doit mettre le nom de la classe de l'objet suivit de parenthèses, puisque comme ça qu'on définit un constructeur.
Sinon, le constructeur de copie n'est pas généralement utilisé dans le cas que tu présentes, cette utilisation est plutôt une utilisation de facto du constructeur de copie.
Mais en fait, et c'est dit dans le cours, le constructeur de copie est utilisé par le compilateur lors de l'initialisation d'une variable. Attention je parle bien de l'initialisation, c'est à dire quand tu écris ça :

// Déclaration et initialisation de David :
Personnage david = goliath;
// À ne pas confondre avec l'affectation :
david = goliath;

Dans le premier cas, le compilateur utilisera le constructeur de copie, dans le deuxième cas, le compilateur utilisera la surcharge de l'opérateur "=" qui prend en paramètre un Personnage.

14 juin 2007 à 23:18:55

Mais new attend bien un type pourtant, non ?
Comme new int, new char[10], ben ici ce serait new Arme. New attend un type et pas un constructeur...
Je suppose que je me trompe mais voici ma pensée

psychoh13

14 juin 2007 à 23:23:22

Bah déjà si tu fais :

Arme *uneArme = new Arme;

C'est comme si tu fasais :

Arme *uneArme = new Arme();

Mais sinon pour les objets c'est un peu différents des types de bases, parce que les types de bases n'ont pas à proprement parler de classe et donc de constructeur, alors que les classes si. Donc pour les objets, instances de classe, new demande un constructeur.

14 juin 2007 à 23:27:40

C'est en fait une particularité du new ?

On peut écrire new arme; mais c'est le constructeur par défaut qui est appelé,
mais on peut écrire new(quelquechose) comme ça c'est le constructeur surchargé ou le constructeur de copie qui est appelé.

J'ai juste cette fois ?

psychoh13

14 juin 2007 à 23:31:06

Oui

Petit bémol, le constructeur de copie fait parti des constructeurs surchargés, c'est une surcharge de constructeur comme une autre. Il ne faut parler de constructeur de copie "à part entière" que lorsqu'on initialise un objet.

14 juin 2007 à 23:31:41

Ok merci beaucoup !!!!

psychoh13

14 juin 2007 à 23:34:33

De rien

lmghs

14 juin 2007 à 23:52:12

new prend prend un type à l'écriture. Optionnellement il peut y avoir des valeurs servant à l'initialisation.

"new int(42)" N'appellera pas de constructeur vu qu'il n'y en a pas pour les int. Par contre, l'entier sera affecté à 42.
"new int" n'appellera aucun constructeur, et n'initialisera rien du tout.

Pour un objet, un constructeur sera appellé après l'allocation. Que cela soit un constructeur d'initialisation paramétré (a), le constructeur de copie (b), ou même un constructeur pouvant dégénérer en construteur par défaut (c) (0 paramètre).

struct Objet {
Objet(int i=42) ; (1)
Objet(Objet const& rhs); (2)
Objet(int i, Objet &o); (3)
};
...

Objet *o1 = new Objet(); // (1), (c)
Objet *o2 = new Objet; // (1), (c)
Objet *o3 = new Objet(42); // (1), (a)
Objet *o4 = new Objet(*o1); // (2), (b)
Objet *o5 = new Objet(42, *o1); // (3), (a)

15 juin 2007 à 0:00:58

Merci beaucoup, c'est très clair maintenant