Big Tuto : Apprenez le C++

Chapitre 14 : Types de données complexes (2)

Tutoriel présenté par : Robert Gillard (Gondulzac)
Date de publication : 15 août 2016
Date de révision : -

     Préliminaires

   Dans le chapitre précédent, nous avons introduit les types de données complexes en commençant par l'implémentation de structures destinées à la création de bases de données. Nous avons vu l'intégration de données membres dans une structure, la création d'objets à partir d'une structure et nous avons créé des fonctions permettant d'ajouter des données ou de relire celles-ci dans les différents champs que comportent ces objets.

   Dans ce chapitre nous allons intégrer des fonctions membres (méthodes) dans une structure. L'utilisation de ces fonctions membres dans les structures va nous permettre d'accéder aux éléments des données sans avoir besoin d'utiliser du code qui n'appartient pas à ces structures. 

   Avec la création d'objets par l'intermédiaire de structures, nous entrons petit-à-petit dans le domaine de la Programmation Orientée Objets ou POO qui sera plus largement expliquée dès l'implémentation des classes C++.  

Retrouvez les projets complets de ce chapitre :

   1 – Structures (suite)
      1.1 – Ajout de fonctions membres dans une structure

   Pour illustrer notre propos sur l'intégration de fonctions membres dans une structure, nous allons de nouveau nous pencher sur le stock d'armes de notre marchand Ethiolas et voir ce qu'il a à nous proposer en matière d'armes dites tranchantes. 

   Nous allons créer une structure ''armes_tranchantes'' qui pourra initialiser des champs représentant des épées courtes, épées longues, épées à deux mains, cimeterres, katanas, ou tout autre arme de ce type que vous pouvez trouver dans un rpg. 

   Les divers champs doivent bien entendu être compatibles avec le type d'arme à créer. En effet, nous ne pouvons pas ici créer un champ dénommé ''portee'' qui représenterait la distance possible que pourrait atteindre une flèche alors que les armes que nous voulons utiliser sont des armes de corps-à-corps. 

   Nous créons donc une structure dénommée ''armes_tranchantes'' à laquelle nous intégrons quelques champs utiles :

   Dans cette structure nous avons ajouté un champ ''degats'' qui représentera les dégats occasionnés par une arme. C'est également important de connaître les dégats causés par la petite merveille que nous allons acheter, autant en avoir pour son argent, non ? 

   Nous allons maintenant compléter la définition de notre structure en lui ajoutant deux fonctions membres, les fonctions ''ajouter_arme()'' et la fonction lire_arme(). La structure devient alors :

   L'implémentation des fonctions se fait en écrivant en premier le type de retour de la fonction, suivi du nom de la structure, de l'opérateur de résolution de portée et du nom de la fonction, soit :

   Et pour la fonction Lire_arme() :

   L'opérateur de résolution de portée nous indique que les fonctions Ajouter_arme() et Lire_arme() font toutes deux partie de la structure ''arme_tranchante''.

   Et enfin dans la fonction main() nous créerons par exemple un objet ''monArme'' et un tableau d'objets ''monTableauArmes''

   Voilà, je ne vous montre pas le résultat dans la console qui est le même que celui du projet 089Struct_7. Voyons plutôt comment nous avons implémenté ce code. 

   Les données membres de notre structure ''armes_tranchantes'' sont désormais des pointeurs et vous voyez que la réservation de la mémoire dans le tas se fait à l'intérieur de la méthode arme_tranchante::Ajouter_arme(). Dans la fonction main(), nous avons créé les objets ''monArme'' et ''monTableauArmes'' sur la pile. La compilation de notre projet 090Struct_8 va donc se faire sans aucun problème et celui-ci tournera parfaitement sur notre PC mais il y a quand-même un problème de taille... 

   Vous ne voyez pas ? 

   Et bien, il n'y a pas de libération de mémoire pour nos variables membres de la structure, dès que nous n'avons plus besoin de celles-ci. Cela ne gêne en rien le déroulement de notre programme mais pourrait se révéler catastrophique lors d'un code beaucoup plus élaboré, alors comment faire !? 

   En gardant telle quelle l'implémentation de ce projet, il nous est impossible de libérer la mémoire pour nos variables membres. Rassurez-vous cependant, nous avons une solution. Nous allons quelque peu empiéter sur la théorie des classes C++ en introduisant la notion de constructeur et de destructeur dans une structure. Après tout, il est parfaitement possible d'avoir à utiliser des fonctions membres d'une structure sans pour cela avoir nécessairement besoin d'une classe.

   1.3 – Notion de constructeur et de destructeur

   Nous laisserons un peu plus de place à la théorie sur les constructeurs et destructeurs lors de la découverte des classes de C++ mais nous allons voir ici ce qui manque à notre programme afin de le rendre plus sûr. 

   Nous avons besoin d'un constructeur et d'un destructeur. Les constructeurs et les destructeurs sont des formes spéciales de fonctions membres qui portent le nom de la structure ou de la classe à laquelle ils se réfèrent et qui ne renvoient aucune valeur, même pas ''void''. Le destructeur est précédé du signe ''~'' (tilde).

   Pour illustrer notre propos, nous pouvons, dans notre projet 090Struct_8, remplacer notre structure ''arme_tranchante'' par celle-ci :

   Structure dans laquelle nous ajoutons les déclarations du constructeur et du destructeur.

   Nous allons maintenant implémenter ceux-ci. Dans le constructeur, nous réserverons la mémoire dans le tas pour nos variables membres et dans le destructeur nous libérerons cette mémoire, ce n'est pas plus difficile que cela.  

   La méthode Ajouter_arme() devenant alors :

   Et dans la fonction main() avant tout appel de fonction, nous ferons appel au constructeur de la même manière qu'une fonction est appelée, c'est-à-dire par son nom :

   Et il n'y a pas à se casser la tête pour chercher où placer le destructeur, celui-ci étant automatiquement appelé dès l'accolade fermante de la fonction main().

   Exercice 2

   A titre d'exercice, vous pouvez réécrire tout le projet 090Struct_8 en utilisant le constructeur et le destructeur que nous venons de voir ci-dessus. 

   1.4 – Implémentation d'une fonction ''inline'' dans une structure

   Nous avons vu que certaines applications sensibles au temps d'exécution pouvaient nécessiter de déclarer l'une ou l'autre fonction ''inline'' (voir chapitre 6 - § 2.1 Fonctions inline). A chaque fois qu'une fonction ''inline'' est appelée, une nouvelle copie de la fonction est insérée dans le programme par le compilateur. Ceci a l'avantage d'augmenter la rapidité d'exécution d'un programme au prix d'un code un peu plus long.

   Une fonction membre d'une structure peut également être déclarée en ligne. L'implémentation d'une telle fonction dans la structure se fait de la façon suivante :

   Le mot-clé ''inline'' n'est pas requis. L'accolade ouvrante de la fonction est placée directement à la suite des parenthèses, suivi du code de la fonction.

   Si nous voulions déclarer ''inline'' la méthode Lire_arme() de notre exemple précédent, nous réécririons notre structure comme ceci :

   et dans ce cas, en ce qui concerne les fonctions membres, nous n'aurions plus qu'à implémenter la méthode ''Ajouter_arme()'' comme nous l'avons fait dans l'exemple précédent. 

   Voilà pour ce qui est de cette grosse partie sur les structures dans les ''Types de données complexes'', nous passons maintenant à un second type, les ''unions''.

   2 – Unions

        2.1 – Définition

   Au même titre qu'une structure, une union est un type de donnée complexe dans laquelle on peut incorporer des types de variables différents mais avec cette importante restriction qu'elle ne peut contenir qu'une seule valeur à un moment donné.

   A titre d'exemple, nous allons déclarer une union qui pourra contenir quelques variables numériques de types différents.
   Une union sera déclarée de la même manière qu'une structure , excepté que le mot réservé union remplarera le mot-clé struct.

   Nous avons déclaré une union dont le type est ''typeVar''. Au même titre qu'une structure, nous pouvons maintenant créer un objet de type ''typeVar'' en écrivant :

typeVar maVariable;

   Nous accéderons de même aux éléments de notre union à l'aide de l'opérateur point en écrivant :

maVariable.ui;
maVariable.i;
maVariable.f;
maVariable.l;
maVariable.d;

   tout en sachant que la variable ''maVariable'' ne peut contenir à un moment donné qu'une seule valeur de l'union, tous les autres membres étant indéfinis.

   Nous allons voir ceci avec un petit exemple :

   2.2 – Exemple

   Pour ce faire, nous allons modifier quelque peu notre projet 007Sizeof du chapitre 2 afin de démontrer que la taille d'une union est de même taille que la taille de la plus grande variable que contient cette union. 

   Après avoir déclaré une union de type ''typeVar'', nous affichons les quantités de mémoire utilisées par chacune des variables contenues dans notre union.

   Nous créons ensuite un objet ''maVariable'' de type ''typeVar'', objet nous permettant d'accéder aux différentes variables de l'union à l'aide de l'opérateur ''point''.

   En passant le type ''typeVar'' à la fonction sizeof(), nous voyons que celle-ci affiche 8 bytes, ce qui représente le type de la variable à qui est allouée la plus grande quantité de mémoire, soit le type double (sur un PC 32 bits). 

  Nous voyons ensuite qu'il nous est impossible d'utiliser en même temps deux variables faisant partie de l'union. Le problème est que le compilateur accepte une telle écriture mais le résultat d'une opération comme celle tentée dans l'exemple donnera un résultat tout-à-fait bizarre, les autres valeurs de l'union étant des valeurs indéfinies. 

   Essayez par exemple d'enlever les doubles-barres de remarque de la ligne !

   et observez le résultat de cette multiplication, vous verrez que nous sommes loin du résultat réel du produit de 3.14159 par 5. 

   Ce qui donne comme résultat dans la console :

   Il est à remarquer qu'une union ne peut pas avoir une référence comme membre et que la norme C++ 11 offre de nouvelles possibilités aux unions. Celles-ci peuvent désormais accueillir des types de classes possédant des constructeurs et des destructeurs.

        3 – Champs de bits

   Un autre type de données complexes sont les champs de bits. Il s'agit d'un type de structure spécial qui permet de ''compresser'' des données contenues dans des variables de la structure.

   Un exemple souvent repris par la littérature informatique pour représenter des champs de bits est la création d'une structure contenant une date.

   struct date
   {
        uint jour;
        uint mois;
        uint annee;
    };

   Nous avons ici une structure dont chaque variable de type unsigned int utilise 4 bytes et la taille de la structure est donc de 4 x 3 = 12 bytes. 

   En utilisant les champs de bits, nous pouvons avoir un arrangement plus compact (pour rappel, 1 byte = 8 bits).

   Voyons ceci avec un court exemple.

   Allez, quelques commentaires. 

   Nous créons deux structures, ''date1'' et ''date2''. Nous venons de voir un peu plus haut qu'une structure contenant 3 variables unsigned int a une taille de 12 bytes.

  Dans la structure ''date2'' nous compressons les données de la façon suivante :

   La variable ''jour'' de type unsigned int dont la taille normale est de 4 bytes est codée sur 5 bits et n'utilise donc qu' un seul byte.

  La variable ''mois'', codée sur 4 bits, n'utilise qu'un byte également tandis que la variable ''annee'', pour afficher les 4 chiffres de 2016 utilise quant-à-elle, 2 bytes.

   Finalement, la taille de la structure ''date2'' est bien de 1 + 1 + 2 = 4 bytes.

   Pour l'écriture de notre date, le gain de mémoire aura donc été de 12 – 4 = 8 bytes. Bon, je sais qu'avec les quantités de mémoires actuelles emmagasinées dans nos Pc's, utiliser les champs de bits dans de telles conditions ne représente que des économies de bout-de-chandelle. Mais puisque cela existe, autant le signaler. 

   Et nous affichons le résultat dans la console :

   Quelques restrictions concernant les champs de bits

   Par convention, les éléments de données que contiennent les champs de bits sont de type ''unsigned int''.

   Les champs de bits n'ayant pas d'adresse, on ne peut donc pas s'y référer avec l'opérateur ''&''.

   En général, l'accès aux champs de bits est moins rapide que l'accès aux variables, ce qui restreint leur utilisation là où une grande vitesse d'exécution est exigée. 

        4 – Enumérations

   Dans le chapitre 2 (Types de données, § 4 – Constantes), nous avons introduit la notion de constantes énumérées et nous en avions présenté un exemple dans le projet 013enum.

   Ce type d'énumérations nous permet de regrouper des ensembles de constantes de type entier non restreints par une ''étendue de validité'' (unscoped enumerations).

   Il se fait que le standard C++ 11 a introduit la notion d'énumérations définies dans une certaine étendue de validité (scoped enumerations). Nous voici donc avec la possibilité d'utiliser deux types d'énumérations différents, chacun d'entre-eux étant définis ou non dans une certaine résolution de portée.

   La déclaration d'une énumération dont les éléments sont définis dans leur étendue de validité se fait en ajoutant le mot-clé ''struct'' ou ''class'' qui suit le mot réservé ''enum''.

  Par exemple, sachant que les modes d'accès à un fichier peuvent être déclarés en mode lecture, écriture ou ajout, nous pouvons, dans le cas d'une ''scoped enumeration'' du standard C++ 11, déclarer une énumération comme suit :

enum struct mode_ouverture { lecture, ecriture, ajout };

   et avoir accès à ses membres (énumérateurs) à l'aide de l'opérateur de résolution de portée :

mode_ouverture mode = mode_ouverture::lecture;

   Enumérateurs

   Les noms des énumérateurs qui font partie d'une ''scoped enumeration'' suivent les règles normales de résolution de portée des variables et sont inaccessibles en dehors de leur étendue de validité.

   En réécrivant le projet 013enum du chapitre 2, nous pouvons mieux constater l'étendue de validité des énumérateurs d'une ''enum PNJ'' (unscoped enumeration) et d'une ''enum struct Personnage''
(scoped enumeration). 

   Voilà, toutes les explications nécessaires sont dans le programme. Dans la ''scoped enumeration'' Personnage, nous déclarons un objet ''Race'' à qui l'on donne la valeur ''Elfe'' et comme nous l'avons vu plus haut, nous ne pourrons accéder à chaque énumérateur de cette énumération qu'à l'aide de l'opérateur de résolution de portée. C'est la différence entre ce programme et celui du projet 013enum du chapitre 2 qui utilisait quant-à-lui une ''unscoped enumeration''.

   Pour résumer :

- unscoped enumeration : Enumération (enum) dont les membres (énumérateurs) ne sont pas restreints à l'étendue de validité de l'énumération.
- scoped enumeration : Enumération (enum struct ou enum class) dont les membres sont restreints à l'étendue de validité de l'énumération.

   5 – Corrigés des exercices du chapitre 13

      Corrigé de l'exercice 1

   Pour cet exercice il était demandé :

   Créez une structure que vous nommerez : arme_de_traits_Arc

   A l'aide du type de cette structure créez trois objets en utilisant l'allocation dynamique de mémoire par laquelle ''new'' renvoie une référence sur un objet créé. Ces 3 objets seront respectivement dénommés arc_court, arc_long et arc_composite.

   Pour chaque objet, vous entrerez les champs de la structure au clavier ainsi que leurs valeurs correspondantes en vous basant sur les exemples cités dans le chapitre 13. Vous créerez également un champ ''prix_revente'' pour chaque objet auquel vous attribuerez respectivement les valeurs 12, 16 et 20.

   Pour terminer, affichez les valeurs saisies pour les champs de chaque objet.

   Voici le code :

   Nous commençons par déclarer notre structure ''armes_de_traits_arc'' comme demandé dans l'énoncé. On déclare ensuite une fonction dénommée ''liberation_memoire()'' à qui l'on passe une référence sur les objets crées dans la fonction main(). La fonction ''libération_memoire()'' va, comme son nom l'indique, libérer la mémoire des trois objets ''arc_court'', ''arc_long'' et ''arc_composite'' créés dans le tas au début de la fonction main() en renvoyant une référence sur chaque objet.

   La fonction main() est ensuite divisée en quatre blocs dont les trois premiers saisissent les différents champs des trois objets créés tandis que le quatrième relit le tout.

   Pour terminer, la fonction ''liberation_memoire()'' est appelée.

   Ce qui nous donne comme résultat dans la console : 

   Corrigé de notre petit challenge (exercice 2)

   L'énoncé de cet exercice étant relativement long, je vous demanderai de bien vouloir vous en rappeler en le relisant tel qu'écrit dans le chapitre 13. Merci de votre compréhension. 

   Voici le code :

   Bien, le but de cet exercice était donc de mettre à jour les stocks de l'inventaire du héros et du marchand après achat de deux petites potions de vie à celui-ci. 

   Au départ, nous créons deux structures dénommées ''inventaire_marchand'' et ''inventaire_heros''.

   La structure ''inventaire_marchand'' ne comporte pas de variable membre ''prix_achat''. Il nous importe peu de savoir comment Ethiolas s'est procuré ses potions ni à quel prix il les a achetées. 

   Nous avons cependant ajouté une variable ''static'', représentant le nom de notre marchand et qui est définie à la suite des structures (voir chapitre 13 - §1.6 : Initialisation d'éléments ''static'' dans une structure).
   Dans la fonction main(), on crée deux objets dans le tas, ''item_marchand'' et ''item_heros'' avec new renvoyant un pointeur sur chacun des objets. Les variables membres de nos deux structures sont ensuite initialisées avec respectivement 5 et 0 comme quantités de potions contenues au départ dans les inventaires de nos personnages. 

   On appelle ensuite la fonction Transactions() en lui passant des pointeurs sur les objets. Dans cette fonction qui ''simule'' l'achat de 2 petites potions de vie par notre héros, nous mettons les deux inventaires à jour en enlevant 2 unités à la variable ''quantite_en_stock'' de l'objet ''item_marchand'' et en ajoutant deux unités à la variable ''quantite_en_stock'' de l'objet ''item_heros''.

   Ce qui affiche dans la console :

   Et voilà, c'est tout en ce qui concerne ce chapitre.

   Les corrigés des exercices de ce chapitre seront présentés à la fin du chapitre 15.

      @ bientôt pour le chapitre 15 – Introduction aux Classes (1).                                                                     

            Gondulzak.