Jeux Libres
       
           

» Les Tutoriels » Apprenez à programmer en C++ ! » Classes et pointeurs

Note : Vous vous apprêtez à lire un tutoriel de M@teo21 et Nanoc initialement publié à cette adresse sous la licence Creative Commons BY-NC-SA 2.0.

Classes et pointeurs


Dans les chapitres précédents, j'ai volontairement évité d'utiliser les pointeurs avec les classes. En effet, les pointeurs en C++ sont un vaste et sensible sujet. Comme vous l'avez probablement remarqué par le passé, bien gérer les pointeurs est essentiel car, à la moindre erreur, votre programme risque de :

  • consommer trop de mémoire parce que vous oubliez de libérer certains éléments ;
  • planter si votre pointeur pointe vers n'importe où dans la mémoire.

Comment associe-t-on classes et pointeurs ? Quelles sont les règles à connaître, les bonnes habitudes à prendre ?
Voilà un sujet qui méritait au moins un chapitre à lui tout seul !

Attention, je classe ce chapitre entre « très difficile » et « très très difficile ». Bref, vous m'avez compris, les pointeurs en C++, ce n'est pas de la tarte alors quadruplez d'attention lorsque vous lirez ce chapitre.





Chapitre précédent     Sommaire     Chapitre suivant


Pointeur d'une classe vers une autre classe


Reprenons notre classe Personnage.
Dans les précédents chapitres, nous lui avons ajouté une Arme que nous avons directement intégrée à ses attributs :
1
2
3
4
5
6
7
8
9
10
11
class Personnage
{
   public:
 
   //Quelques mthodes?
 
   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, cela donnerait quelque chose de comparable à la figure suivante.


Vous le voyez, l'Arme est vraiment dans le Personnage.

Il y a une autre technique, plus souple, qui offre 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 :
1
2
3
4
5
6
7
8
9
10
11
12
class Personnage
{
   public:
 
   //Quelques mthodes?
 
   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 (figure suivante).


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

Les pointeurs permettent de régler le problème que l'on avait vu pour le jeu de stratégie Warcraft III : un personnage peut avoir une cible qui change grâce à un pointeur interne, exactement comme ici.


Mais des défauts, il y en a aussi. Gérer une classe qui contient des pointeurs, ce n'est pas de la tarte, vous pouvez me croire, et d'ailleurs vous allez le constater.

Alors, faut-il utiliser un pointeur ou pas pour l'Arme ? Les 2 façons de faire sont valables et chacune a ses avantages et ses 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.



Gestion de l'allocation dynamique


On va voir ici comment on travaille quand une classe contient des pointeurs vers des objets.

On travaille là encore sur la classe Personnage et je suppose que vous avez mis l'attribut m_arme en pointeur comme je l'ai montré un peu plus haut :
1
2
3
4
5
6
7
8
9
10
11
12
class Personnage
{
   public:
 
   //Quelques mthodes?
 
   private:
 
   Arme *m_arme;
   //L'Arme est un pointeur, l'objet n'est plus contenu dans le Personnage
   //?
};

Je ne réécris volontairement pas tout le code, juste l'essentiel pour que nous puissions nous concentrer dessus.


Notre Arme étant un pointeur, il va falloir le créer par le biais d'une allocation dynamique avec new. Sinon, l'objet ne se créera pas tout seul.

Allocation de mémoire pour l'objet



À votre avis, où se fait l'allocation de mémoire pour notre Arme ?
Il n'y a pas 36 endroits pour cela : c'est dans le constructeur. C'est en effet le rôle du constructeur de faire en sorte que l'objet soit bien construit, donc notamment que tous les pointeurs pointent vers quelque chose.

Dans notre cas, nous sommes obligés de faire une allocation dynamique, donc d'utiliser new. Voici ce que cela donne dans le constructeur par défaut :
1
2
3
4
Personnage::Personnage() : m_arme(0), 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 voulaient que le Personnage commence avec une arme plus puissante dès le début. Il faut là aussi y faire une allocation dynamique :
1
2
3
4
Personnage::Personnage(string nomArme, int degatsArme) : m_arme(0), m_vie(100), m_mana(100)
{
   m_arme = new Arme(nomArme, degatsArme);
}

Voici sans plus attendre les explications : 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.

Par sécurité, on initialise d'abord le pointeur à 0 dans la liste d'initialisation puis on fait l'allocation avec le new entre les accolades du constructeur.

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 se contente d'un new dans le constructeur, et qu'on ne met rien dans le destructeur, lorsque l'objet de type Personnage est détruit nous avons un problème (figure suivante).


L'objet de type Personnage disparaît bel et bien mais l'objet de type Arme subsiste en mémoire et il n'y a plus aucun pointeur pour se « rappeler » son adresse. En clair, l'Arme va traîner en mémoire et on ne pourra plus jamais la supprimer. C'est ce qu'on appelle une fuite de mémoire.

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 :
1
2
3
4
Personnage:: Personnage()
{
   delete m_arme;
}

Cette fois le destructeur est réellement indispensable. Maintenant, lorsque quelqu'un demande à détruire le Personnage, il se passe ceci :

  1. Appel du destructeur? et donc, dans notre cas, suppression de l'Arme (avec le delete) ;
  2. Puis suppression du Personnage.

Au final, les deux objets sont bel et bien supprimés et la mémoire reste propre (figure suivante).


N'oubliez pas que m_arme est maintenant un pointeur !

Cela implique de changer toutes les méthodes qui l'utilisent. Par exemple :
1
2
3
4
void Personnage::attaquer(Personnage &cible)
{
   cible.recevoirDegats(m_arme.getDegats());
}

? devient :
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.



Le pointeur this


Ce chapitre étant difficile, je vous propose un passage un peu plus cool. Puisqu'on parle de POO et de pointeurs, je me dois de vous parler du pointeur this.

Dans toutes les classes, on dispose d'un pointeur ayant pour nom this, qui pointe vers l'objet actuel.
Je reconnais que ce n'est pas simple à imaginer mais je pense que cela passera mieux avec un schéma maison (figure suivante).


Chaque objet (ici de type Personnage) possède un pointeur this qui pointe vers? l'objet lui-même !

this étant utilisé par le langage C++ dans toutes les classes, vous ne pouvez pas créer de variable appelée this car cela susciterait un conflit. De même, si vous commencez à essayer d'appeler vos variables class, new, delete, return, etc. vous aurez un problème.
Ces mots-clés sont ce qu'on appelle des « mots-clés réservés ». Le langage C++ se les réserve pour son usage personnel, vous n'avez donc pas le droit de créer des variables (ou des fonctions) portant ces noms-là.


Mais? à quoi peut bien servir this ?


Répondre à cette question me sera délicat.
En revanche 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 cela pourrait donner :
1
2
3
4
Personnage* Personnage::getAdresse() const
{
   return this;
}

Nous l'avons en fait déjà rencontré une fois, lors de la surcharge de l'opérateur +=. Souvenez-vous, notre opérateur ressemblait à ceci :
1
2
3
4
5
6
Duree& Duree::operator+=(const Duree &duree2)
{
   //Des calculs compliqus?
 
   return *this;
}

this étant un pointeur sur un objet, *this est l'objet lui-même ! Notre opérateur renvoie donc l'objet lui-même. La raison pour laquelle on doit renvoyer l'objet est compliquée mais c'est la forme correcte des opérateurs. Je vous propose donc simplement d'apprendre cette syntaxe par c?ur.

À part pour la surcharge des opérateurs, vous n'avez certainement pas à utiliser this dans l'immédiat 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. Cela 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 !


Le constructeur de copie


Le constructeur de copie est une surcharge particulière du constructeur.

Le constructeur de copie devient généralement indispensable dans une classe qui contient des pointeurs et cela tombe bien vu que c'est précisément notre cas ici.

Le problème



Pour bien comprendre l'intérêt du constructeur de copie, voyons concrètement ce qui se passe lorsqu'on crée un objet en lui affectant? un autre objet ! Par exemple :
1
2
3
4
5
6
7
8
9
int main()
{
   Personnage goliath("Epe aiguise", 20);
   
   Personnage david(goliath);
   //On cre 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, 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, le 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 lui affectant la valeur d'un autre :
1
Personnage david(goliath); //Appel du constructeur de copie (cas 1)

Ceci est strictement équivalent à :
1
Personnage david = goliath; //Appel du constructeur de copie (cas 2)

Dans ce second cas, c'est aussi au constructeur de copie qu'on fait 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é !
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, au moment de l'appel de la fonction, un constructeur de copie :
1
maFonction(Goliath); //Appel du constructeur de copie (cas 3)

Bien entendu, il est généralement préférable d'utiliser une référence car l'objet n'a pas besoin d'être copié. Cela va donc bien plus vite et nécessite moins de mémoire. Toutefois, il arrivera des cas où vous aurez besoin de créer une fonction qui, comme ici, fait une copie de l'objet.

Si vous n'écrivez pas vous-mêmes un constructeur de copie pour votre classe, il sera généré automatiquement pour vous par le compilateur. Ok, c'est sympa de sa part mais le compilateur est? bête (pour ne pas le froisser).

En fait, le constructeur de copie généré se contente de copier la valeur de tous les attributs? et même des pointeurs !


Le problème ? Eh bien justement, il se trouve que, dans notre classe Personnage, un des attributs est un pointeur ! 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 (figure suivante) !

Ah les fourbes !


L'ordinateur a copié le pointeur, les deux Personnages pointent vers la même Arme

Si on ne fait rien pour régler cela, imaginez ce qui se passe lorsque les deux personnages sont détruits? Le premier est détruit ainsi que son arme car le destructeur ordonne la suppression de l'arme avec un delete. Et quand arrive le tour du second personnage, le delete plante (et votre programme avec) parce que l'arme a 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, qui prend pour paramètre? une référence constante vers un objet du même type !

Si vous ne trouvez pas cela clair, peut-être qu'un exemple vous aidera.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Personnage
{
   public:
 
   Personnage();
Personnage(Personnage const& personnageACopier);
   //Le prototype du constructeur de copie
   Personnage(std::string nomArme, int degatsArme);
    Personnage();
   
   /*
   ? plein d'autres mthodes qui ne nous intressent pas ici
   */

 
   private:
 
   int m_vie;
   int m_mana;
   Arme *m_arme;
};

En résumé, le prototype d'un constructeur de copie est :
1
Objet(Objet const& objetACopier);

Le const indique simplement que l'on n'a pas le droit de modifier les valeurs de l'objetACopier (c'est logique, on a seulement besoin de « lire » ses valeurs pour le copier).

Écrivons l'implémentation de ce constructeur. Il faut 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 :
1
2
3
4
5
Personnage::Personnage(Personnage const& personnageACopier)
  : m_vie(personnageACopier.m_vie), m_mana(personnageACopier.m_mana), m_arme(0)
{
 
}

Vous vous demandez peut-être comment cela se fait qu'on puisse accéder aux attributs m_vie et m_mana du personnageACopier ? Si vous vous l'êtes demandé, je vous félicite, cela veut dire que le principe d'encapsulation commence à rentrer dans votre tête.

Eh oui, en effet, m_vie et m_mana sont privés donc on ne peut pas y accéder depuis l'extérieur de la classe? sauf qu'il y a une exception ici : on est dans une méthode de la classe Personnage et on a donc le droit d'accéder à tous les éléments (même privés) d'un autre Personnage. C'est un peu tordu, je l'avoue, mais dans le cas présent cela nous simplifie grandement la vie. Retenez donc qu'un objet de type X peut accéder à tous les éléments (même privés) d'un autre objet du même type X.


Il reste maintenant à « copier » m_arme. Si on écrit :
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 non l'objet en entier !

Pour résoudre le problème, il faut 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 :
1
m_arme = new Arme();

? on crée bien une nouvelle Arme mais on utilise le constructeur par défaut, donc cela crée l'Arme de base. Or on veut avoir exactement la même Arme que celle du personnageACopier (eh bien 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 cela tombe bien, la classe Arme n'utilise pas de pointeur, on peut donc se contenter du constructeur qui a été généré.

Il faut donc appeler le constructeur de copie de Arme, en passant en paramètre l'objet à copier. Vous pourriez penser qu'il faut faire ceci :
1
m_arme = new Arme(personnageACopier.m_arme);

Presque ! Sauf que m_arme est un pointeur et le prototype du constructeur de copie est :
1
Arme(Arme const& arme);

... ce qui veut dire qu'il faut envoyer l'objet lui-même et pas son adresse. Vous vous souvenez de la manière d'obtenir l'objet (ou la variable) à partir de son adresse ? On utilise l'étoile * !

Cela donne au final :
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 constructeur de copie correct ressemblera donc au final à ceci :
1
2
3
4
5
Personnage::Personnage(Personnage const& personnageACopier)
  : m_vie(personnageACopier.m_vie), m_mana(personnageACopier.m_mana), m_arme(0)
{
   m_arme = new Arme(*(personnageACopier.m_arme));
}

Ainsi, nos deux personnages ont chacun une arme identique mais dupliquée, afin d'éviter les problèmes que je vous ai expliqués plus haut (figure suivante).


L'opérateur d'affectation



Nous avons déjà parlé de la surcharge des opérateurs mais il y en a un que je ne vous ai pas présenté : il s'agit de l'opérateur d'affectation (operator=).

Le compilateur écrit automatiquement un opérateur d'affectation par défaut mais c'est un opérateur « bête ». Cet opérateur bête se contente de copier une à une les valeurs des attributs dans le nouvel objet, comme pour le constructeur de copie généré par le compilateur.


La méthode operator= sera appelée dès qu'on essaie d'affecter une valeur à l'objet. C'est le cas, par exemple, si nous affectons à notre objet la valeur d'un autre objet :
1
david = goliath;

Ne confondez pas le constructeur de copie avec la surcharge de l'opérateur = (operator=). Ils se ressemblent beaucoup mais il y a une différence : le constructeur de copie est appelé lors de l'initialisation (à la création de l'objet) tandis que la méthode operator= est appelée si on essaie d'affecter un autre objet par la suite, après son initialisation.
1
2
Personnage david = goliath; //Constructeur de copie
david = goliath; //operator=


Cette méthode effectue le même travail que le constructeur de copie. Écrire son implémentation est donc relativement simple, une fois qu'on a compris le principe bien sûr.
1
2
3
4
5
6
7
8
9
10
11
12
Personnage& Personnage::operator=(Personnage const& personnageACopier)
{
   if(this != &personnageACopier)
   //On vrifie que l'objet n'est pas le mme que celui reu en argument
   {
       m_vie = personnageACopier.m_vie; //On copie tous les champs
       m_mana = personnageACopier.m_mana;
   delete m_arme;
       m_arme = new Arme(*(personnageACopier.m_arme));
   }
   return *this; //On renvoie l'objet lui-mme
}

Il y a tout de même quatre différences :

  • Comme ce n'est pas un constructeur, on ne peut pas utiliser la liste d'initialisation et donc tout se passe entre les accolades.

  • Il faut penser à vérifier que l'on n'est pas en train de faire david=david, que l'on travaille donc avec deux objets distincts. Il faut donc vérifier que leurs adresses mémoires (this et &personnageACopier) soient différentes.

  • Il faut renvoyer *this comme pour les opérateurs +=, -=, etc. C'est une règle à respecter.

  • Il faut penser à supprimer l'ancienne Arme avant de créer la nouvelle. C'est ce qui est fait au niveau de l'instruction delete, surlignée dans le code. Ceci n'était pas nécessaire dans le constructeur de copie puisque le personnage ne possédait pas d'arme avant.

Cet opérateur est toujours similaire à celui que je vous donne pour la classe Personnage. Les seuls éléments qui changent d'une classe à l'autre sont les lignes figurant dans le if. Je vous ai en quelque sorte donné la recette universelle.

Il y a une chose importante à retenir au sujet de cet opérateur : il va toujours de pair avec le constructeur de copie.

Si l'on a besoin d'écrire un constructeur de copie, alors il faut aussi obligatoirement écrire une surcharge de operator=.


C'est une règle très importante à respecter. Vous risquez de graves problèmes de pointeurs si vous ne la respectez pas.

Comme vous commencez à vous en rendre compte, la POO n'est pas simple, surtout quand on commence à manipuler des objets avec des pointeurs. 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.




En résumé



  • Pour associer des classes entre elles, on peut utiliser les pointeurs : une classe peut contenir un pointeur vers une autre classe.

  • Lorsque les classes sont associées par un pointeur, il faut veiller à bien libérer la mémoire afin que tous les éléments soient supprimés.

  • Il existe une surcharge particulière du constructeur appelée « constructeur de copie ». C'est un constructeur appelé lorsqu'un objet doit être copié. Il est important de le définir lorsqu'un objet utilise des pointeurs vers d'autres objets.

  • Le pointeur this est un pointeur qui existe dans tous les objets. Il pointe vers... l'objet lui-même.



Chapitre précédent     Sommaire     Chapitre suivant



Distribué et adapté par David
Consulté 3064 fois



Hébergeur du site : David
Version PHP : 5.4.45-0+deb7u2
Uptime : 240 jours 12 heures 7 minutes
Espace libre : 1569 Mo
Dernière sauvegarde : 22/07/2019
Taille de la sauvegarde : 1112 Mo


5357216 pages ont été consultées sur le site !
Dont 2687 pages pendant les 24 dernières heures.

Page générée en 0.549 secondes


Nos sites préférés
- Création d'un jeu de plateforme de A à Z avec SDL
- Zelda ROTH : Jeux amateurs sur le thème de Zelda
- Zeste de Savoir : la connaissance pour tous et sans pépins
- YunoHost : s'héberger soi-même en toute simplicité
- Site de Fvirtman : recueil de projets et de codes en C et C++
- Par ici la sortie : le site des idées de sorties


  © 2005-2019 linor.fr - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.