Reprenons notre classe Personnage
Dans le dernier chapitre, nous lui avons ajouté une Arme que nous avons directement intégré à ses attributs :
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12 | class Personnage
{
public:
// Quelques méthodes...
private:
Arme m_arme; // L'Arme est "contenue" dans le Personnage
// ...
};
|
Il y a plusieurs façons différentes d'associer des classes entre elles. Celle-ci fonctionne bien dans notre cas, mais l'Arme est vraiment "liée" au Personnage. Elle ne peut pas en sortir.
Schématiquement, ça donnerait quelque chose de ce genre :
L'Arme est vraiment
dans le Personnage.
Il y a une autre technique, plus souple, qui permet plus de possibilités, mais qui est plus complexe : ne pas intégrer l'Arme au Personnage et utiliser un pointeur à la place. Au niveau de la déclaration de la classe, le changement correspond à... une étoile en plus :
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12 | class Personnage
{
public:
// Quelques méthodes...
private:
Arme *m_arme; // L'Arme est un pointeur, l'objet n'est plus contenu dans le Personnage
// ...
};
|
Notre Arme étant un pointeur, on ne peut plus dire qu'elle appartient au Personnage.
En schéma, ça donne ça :
On considère que l'arme est maintenant externe au personnage.
Les avantages de cette technique sont les suivants :
- Le Personnage peut changer d'Arme en faisant tout simplement pointer m_arme vers un autre objet. Par exemple, si le Personnage possède un inventaire (dans un sac à dos), il peut changer son Arme à tout moment en modifiant le pointeur.
- Le Personnage peut donner son Arme à un autre Personnage, il suffit de changer les pointeurs de chacun des personnages.
- Si le Personnage n'a plus d'Arme, il suffit de mettre le pointeur m_arme à NULL.
Mais des défauts, il y en a aussi. Gérer une classe qui contient des pointeurs, c'est pas de la tarte vous pouvez me croire, et d'ailleurs vous allez le voir
Alors, faut-il utiliser un pointeur ou pas pour l'arme ? Les 2 façons de faire sont valables, et ont chacune leurs avantages et défauts. Utiliser un pointeur est probablement ce qu'il y a de plus souple, mais c'est aussi plus difficile.
Retenez donc qu'il n'y a pas de "meilleure" méthode adaptée à tous les cas, ce sera à vous de choisir en fonction de votre cas si vous intégrez directement un objet dans une classe ou si vous utilisez un pointeur.
On va ici voir comment on travaille quand une classe contient des pointeurs vers des objets.
On travaille là encore sur notre classe Personnage et je suppose que vous avez mis l'attribut m_arme en pointeur comme je l'ai montré un peu plus haut :
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12 | class Personnage
{
public:
// Quelques méthodes...
private:
Arme *m_arme; // L'Arme est un pointeur, l'objet n'est plus contenu dans le Personnage
// ...
};
|
Notre arme étant un pointeur, il va falloir faire une allocation dynamique avec
new pour créer l'objet. Sinon, l'objet ne se créera pas tout seul
Allocation de mémoire pour l'objet
L'allocation de mémoire pour notre arme se fait où à votre avis ?
Il n'y a pas 36 endroits pour ça : c'est dans le
constructeur. C'est en effet le rôle du constructeur que de faire en sorte que l'objet soit bien construit, donc notamment que tous les pointeurs pointent vers quelque chose
Dans notre cas, on est obligé de faire une allocation dynamique, donc d'utiliser
new. Voici ce que ça donne dans le constructeur par défaut :
Code : C++1
2
3
4 | Personnage::Personnage() : m_vie(100), m_mana(100)
{
m_arme = new Arme();
}
|
Si vous vous souvenez bien, on avait aussi fait un second constructeur pour ceux qui veulent que le Personnage commence avec une arme plus puissante dès le départ. Il faut là aussi y faire une allocation dynamique :
Code : C++1
2
3
4 | Personnage::Personnage(string nomArme, int degatsArme) : m_vie(100), m_mana(100)
{
m_arme = new Arme(nomArme, degatsArme);
}
|
new Arme() appelle le constructeur par défaut de la classe Arme, tandis que new Arme(nomArme, degatsArme) appelle le constructeur surchargé. Le new renvoie l'adresse de l'objet créé, adresse qui est stockée dans notre pointeur m_arme.
On ne peut pas faire de new dans la liste d'initialisation, ce qui explique pourquoi on le fait entre les accolades { }.
Désallocation de mémoire pour l'objet
Notre arme étant un pointeur, lorsque l'objet de type Personnage est supprimé l'arme ne disparaît pas toute seule ! Si on fait juste un new dans le constructeur, et rien dans le destructeur, il va se passer ceci lorsque l'objet de type Personnage sera détruit :
L'objet de type Personnage va bel et bien disparaître, mais l'objet de type Arme va subsister en mémoire et il n'y aura plus aucun pointeur pour se "rappeler" de son adresse. En clair, l'arme va traîner en mémoire et on ne pourra plus jamais la supprimer.
Pour résoudre ce problème, il faut faire un delete de l'arme dans le
destructeur du personnage afin que l'arme soit supprimée
avant le personnage. Le code est tout simple :
Code : C++1
2
3
4 | Personnage::~Personnage()
{
delete m_arme;
}
|
Cette fois le destructeur est réellement indispensable. Maintenant, lorsque quelqu'un demandera à détruire le Personnage, il va se passer ceci :
- Appel du destructeur... et donc dans notre cas suppression de l'Arme (avec le delete).
- Puis enfin suppression du Personnage.
Au final, les 2 objets seront bel et bien supprimés et la mémoire sera propre :
N'oubliez pas que m_arme est maintenant un pointeur !
Cela implique de changer toutes les méthodes qui l'utilisent. Par exemple :
Code : C++1
2
3
4 | void Personnage::attaquer(Personnage &cible)
{
cible.recevoirDegats(m_arme.getDegats());
}
|
... devient :
Code : C++1
2
3
4 | void Personnage::attaquer(Personnage &cible)
{
cible.recevoirDegats(m_arme->getDegats());
}
|
Notez la différence : le point a été remplacé par la flèche, car m_arme est un pointeur. Cela ne devrait pas être nouveau pour vous si vous avez bien suivi le cours jusqu'ici, mais je préfère le rappeler sait-on jamais
Le
constructeur de copie, c'est une
surcharge particulière du constructeur.
Le constructeur de copie devient généralement indispensable dans une classe qui contient des pointeurs, et ça tombe bien vu que c'est justement notre cas ici
Le problème
Pour bien comprendre l'intérêt du constructeur de copie, voyons voir concrètement ce qui se passe lorsqu'on crée un objet en l'affectant par... un autre objet ! Par exemple :
Code : C++1
2
3
4
5
6
7
8 | int main()
{
Personnage goliath("Epée aiguisée", 20);
Personnage david = goliath; // On crée david à partir de goliath. David sera une "copie" de goliath.
return 0;
}
|
Lorsqu'on construit un objet en lui affectant directement un autre objet, comme on vient de le faire ici avec le signe "=", le compilateur appelle une méthode appelée constructeur de copie.
Le rôle du constructeur de copie est de
copier la valeur de tous les attributs du premier objet dans le second. Donc david récupère la vie de goliath, la mana de goliath, etc.
Dans quels cas le constructeur de copie est-il appelé ?
On vient de le voir, le constructeur de copie est appelé lorsqu'on crée un nouvel objet en l'affectant par la valeur d'un autre :
Code : C++1 | Personnage david = goliath; // Appel du constructeur de copie (cas 1)
|
Ceci est strictement équivalent à écrire :
Code : C++1 | Personnage david(goliath); // Appel du constructeur de copie (cas 2)
|
Dans ce second cas le constructeur de copie est là aussi appelé.
Mais ce n'est pas tout ! Lorsque vous envoyez un objet à une fonction sans utiliser de pointeur ni de référence, l'objet est là aussi copié !
Imaginons la fonction :
Code : C++1
2
3
4 | void maFonction(Personnage unPersonnage)
{
}
|
Si vous appelez cette fonction qui n'utilise pas de pointeur ni de référence, alors l'objet sera copié en utilisant un constructeur de copie au moment de l'appel de la fonction :
Code : C++1 | maFonction(Goliath); // Appel du constructeur de copie (cas 3)
|
Bien entendu, il est préférable d'utiliser un pointeur ou une référence en général car l'objet n'a pas besoin d'être copié, donc ça va bien plus vite et ça prend moins de mémoire. Toutefois, il arrivera des cas où vous aurez besoin de créer une fonction comme ici qui fait une copie de l'objet.
Le problème ? Eh bien justement, il se trouve qu'un des attributs est un pointeur dans notre classe Personnage ! Que fait l'ordinateur ? Il copie la valeur du pointeur, donc l'adresse de l'arme. Au final, les 2 objets ont un pointeur qui pointe vers le même objet de type Arme !
Ah les fourbes !
L'ordinateur a copié le pointeur, et donc les 2 pointeurs pointent vers la même arme !Si on ne fait rien pour régler ça, imaginez ce qu'il va se passer lorsque les 2 personnages seront détruits... Le premier sera détruit, ainsi que son arme car le destructeur ordonnera la suppression de l'arme avec un delete. Et quand arrivera le tour du second personnage, le delete va planter (et votre programme avec
) parce que l'arme aura
déjà été détruite !
Le constructeur de copie généré automatiquement par le compilateur n'est pas assez intelligent pour comprendre qu'il faut allouer de la mémoire pour une autre arme... Qu'à cela ne tienne, nous allons le lui expliquer
Création du constructeur de copie
Le constructeur de copie, comme je vous l'ai dit un peu plus haut, est une surcharge particulière du constructeur. C'est un constructeur qui prend pour paramètre... une référence constante vers un objet du même type !
Si vous trouvez pas ça clair, peut-être qu'un exemple vous aidera
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | class Personnage
{
public:
Personnage();
Personnage(const Personnage &personnageACopier); // Le prototype du constructeur de copie
Personnage(std::string nomArme, int degatsArme);
~Personnage();
/*
... plein d'autres méthodes qui ne nous intéressent pas ici
*/
private:
int m_vie;
int m_mana;
Arme *m_arme;
};
|
En résumé, le prototype d'un constructeur de copie est :
Code : C++1 | Objet(const Objet &objetACopier);
|
Le const indique juste qu'on n'a pas le droit de modifier les valeurs de l'objetACopier (c'est logique, on a juste besoin de "lire" ses valeurs pour le copier).
Ecrivons l'implémentation de ce constructeur. Il va falloir copier tous les attributs du personnageACopier dans le personnage actuel. Commençons par les attributs "simples", c'est-à-dire ceux qui ne sont pas des pointeurs :
Code : C++1
2
3
4
5 | Personnage::Personnage(const Personnage &personnageACopier)
{
m_vie = personnageACopier.m_vie;
m_mana = personnageACopier.m_mana;
}
|
Il reste maintenant à "copier" m_arme. Si on écrit :
Code : C++1 | m_arme = personnageACopier.m_arme;
|
... on fait exactement la même erreur que le compilateur, c'est-à-dire qu'on ne copie que l'adresse de l'objet de type Arme, et pas l'objet en entier !
Pour résoudre le problème, il va falloir copier l'objet de type Arme en faisant une allocation dynamique, donc un new. Attention, accrochez-vous parce que ce n'est pas simple
Si on fait :
Code : C++
... on va bien créer une nouvelle arme, mais on utilisera le constructeur par défaut, donc cela créera l'arme de base. Or, on veut avoir exactement la même arme que celle du personnageACopier (ben oui, c'est un constructeur de copie
).
La bonne nouvelle, comme je vous l'ai dit plus haut, c'est que le constructeur de copie est automatiquement généré par le compilateur. Tant que la classe n'utilise pas de pointeurs vers des attributs, il n'y a pas de danger. Et ça tombe bien, la classe Arme n'utilise pas de pointeurs, on va donc pouvoir se contenter du constructeur qui a été généré.
Il faut donc appeler le constructeur de copie, en envoyant en paramètre l'objet à copier. Vous pourriez penser qu'il faut faire ceci :
Code : C++1 | m_arme = new Arme(personnageACopier.m_arme);
|
Presque ! Sauf que m_arme est un pointeur, et le prototype du constructeur de copie est :
Code : C++
... ce qui veut dire qu'il faut envoyer l'objet lui-même et pas son adresse. Vous vous souvenez comment on fait pour obtenir l'objet (ou la variable) à partir de son adresse ? On utilise l'étoile * !
Ce qui donne au final :
Code : C++1 | m_arme = new Arme(*(personnageACopier.m_arme));
|
Cette ligne alloue dynamiquement une nouvelle arme, en se basant sur l'arme du personnageACopier. Pas simple je le reconnais, mais relisez plusieurs fois les étapes de mon raisonnement et vous allez comprendre
Pour bien suivre tout ce que j'ai dit, il faut vraiment que vous soyez au point sur tout : les pointeurs, les références, et les... constructeurs de copie
Le constructeur de copie une fois terminé
Le bon constructeur de copie ressemblera donc à ceci au final :
Code : C++1
2
3
4
5
6 | Personnage::Personnage(const Personnage &personnageACopier)
{
m_vie = personnageACopier.m_vie;
m_mana = personnageACopier.m_mana;
m_arme = new Arme(*(personnageACopier.m_arme));
}
|
Ainsi, nos 2 personnages ont tous deux une arme identique, mais dupliquée afin d'éviter les problèmes que je vous ai expliqués plus haut :
Notez qu'on peut aussi utiliser la liste d'initialisation pour tous les attributs qui ne nécessitent pas d'allocation dynamique, à savoir m_vie et m_mana. On peut donc aussi écrire le constructeur de copie de cette manière :
Code : C++1
2
3
4 | Personnage::Personnage(const Personnage &personnageACopier) : m_vie(personnageACopier.m_vie), m_mana(personnageACopier.m_mana)
{
m_arme = new Arme(*(personnageACopier.m_arme));
}
|
La POO n'est pas simple comme vous commencez à vous en rendre compte, surtout quand on commence à manipuler des objets. Heureusement, vous aurez l'occasion de pratiquer tout cela par la suite, et vous allez petit à petit prendre l'habitude d'éviter les pièges des pointeurs.
Pour terminer ce chapitre sur une note plus
cool, puisqu'on parle de POO et de pointeurs, je me dois de vous parler du pointeur
this.
Pas de panique, c'est très simple, ça ira vite et vous ne sentirez aucune douleur
Dans toutes les classes, on dispose d'un pointeur ayant pour nom
this. Ce pointeur pointe
vers l'objet actuel.
Je reconnais que ce n'est pas simple à imaginer, mais je pense que ça passera mieux avec un schéma maison :
Chaque objet (ici de type Personnage) possède un pointeur this qui pointe vers... l'objet lui-même !Mais... à quoi peut bien servir this ???
Répondre à cette question me sera délicat
Je peux vous donner un exemple : vous êtes dans une méthode de votre classe, et cette méthode doit renvoyer un pointeur vers l'objet auquel elle appartient. Sans le this, on ne pourrait pas l'écrire. Voilà ce que ça pourrait donner :
Code : C++1
2
3
4 | Personnage* Personnage::getAdresse()
{
return this;
}
|
Dans l'immédiat, vous n'en avez certainement pas l'utilité, mais il arrivera un jour où, pour résoudre un problème particulier, vous aurez besoin d'un tel pointeur. Ce jour-là, souvenez-vous qu'un objet peut "retrouver" son adresse à l'aide du pointeur this.
Comme c'est l'endroit le plus adapté pour en parler dans ce cours, j'en profite. Ca ne va pas changer votre vie tout de suite, mais il se peut que bien plus tard, dans plusieurs chapitres je vous dise tel un vieillard sur sa canne "
Souvenez-vous, souvenez-vous du pointeur this ! 
". Alors ne l'oubliez pas
Si vous êtes en train de vous shooter à l'aspirine pour éviter que votre tête n'explose, je vous conseille de conserver encore des munitions
En effet, on n'a pas fini d'en découdre avec la POO et il vous reste encore beaucoup de choses à apprendre. Heureusement, enfin si ça peut vous rassurer, ce chapitre était probablement l'un des plus difficiles de tout le cours (mais pas nécessairement LE plus difficile
).
Sachez quoiqu'il en soit que les pointeurs en C++ sont de véritables casse-têtes, même pour les programmeurs plus expérimentés. Il faut faire constamment attention, car une fuite de mémoire (oubli de libérer des objets) est très vite arrivée, et je ne vous parle pas des plantages de programme que ça peut occasionner. Une très très grande part des plantages des programmes que vous connaissez sont dûs à une mauvaise gestion de la mémoire, c'est vous dire !
Dans le prochain chapitre, nous allons jouer avec la
surcharge des opérateurs, ce qui va nous permettre de faire des choses étonnantes avec nos objets.
Puis, chemin faisant, nous nous rapprocherons d'un des thèmes majeurs de la programmation orientée objet, quelque chose d'indispensable à quoi vous ne pouvez échapper et qui porte un bien funeste nom :
l'héritage. Voilà un peu le genre de choses qui vous attend
Qu'on ne s'y trompe pas : tout ceci est peut-être complexe et pas toujours très "amusant" à apprendre, mais vous en aurez vraiment besoin dans la partie II lorsque nous travaillerons avec la librairie Qt pour créer des fenêtres, travailler en réseau, etc. Donc on se motive, et on continue !
Flux RSS News
Twitter
Facebook