C et C++ partie G
Par O. Bailleux, Maître de conférences HDR à l'université de Bourgogne.
C++ : classes et instances
Les activités #.dec (dec pour Découverte) consistent à étudier des présentations explicatives et à traiter tous les exercices de découverte proposés. Si vous ne répondez pas correctement à un exercice de découverte, revenez en arrière pour relire les explications et identifier la cause de votre erreur.
Les activités #.ent (ent pour Entrainement) consistent à traiter des exercices d’entraînement. Vous devez d’abord tenter de traiter ces exercices sans dévoiler d’indice ni regarder la solution. Vous pouvez remonter dans le document pour relire certaines explications ou consulter les solutions des exercices de découverte ou d’entraînement précédemment traités.
Activité de découverte G.dec
Dans cet enseignement, nous n’aborderons qu’un fragment du langage C++. De nombreux aspects ne seront pas abordés.
G.dec1 : Utilisation d’une classe
Dans cette section, nous allons découvrir la notion de classe en programmation orientée objet du point de vue de l’utilisation d’une classe existante, en l’occurrence la classe string, qui permet de représenter des chaines de caractères.
Prérequis
| Parties A, C et D |
|---|
Objectif
| Faciliter l’utilisation de chaînes de caractères |
|---|
La représentation des chaînes en langage C (partie D) est très rudimentaire, avec pour conséquence des risques important d’erreurs, de "bugs" lors de la conception d’applications les utilisant.
L’objectif de la classe string du C++, qui nous sert ici d’exemple introductif pour présenter le concept de classe du point de vue de leur utilisation, est de rendre plus simple et plus sécurisée l’utilisation de chaines de caractères dans des applications.
Moyen
| La classe string du C++ |
|---|
Dans cette section, nous nous intéressons à la classe string vue de l’extérieur, c’est à dire sans nous soucier de la manière dont elle est programmée. C’est un des intérêts de la programmation objet de rendre l’utilisation d’une classe complètement indépendante de sa conception.
Une classe est en quelques sorte un modèle permettant de créer des objets qui sont aussi appelés instances de la classe.
Les instances de la classe string représentent des chaînes de caractères. Elles peuvent se trouver dans la pile ou dans le tas. L’exemple suivant montre comment créer une instance de string dans la pile et une autre dans le tas.
Pour compiler cet exemple, il faut placer les lignes suivantes au début du fichier source :
#include <iostream>
#include <string>
using namespace std;
Les deux premières lignes sont des inclusions de fichiers d’entête. La troisième permettra d’utiliser par défaut l’espace de nommage std. Sans cette ligne, la classe string devrait être nommée std::string. Les espaces de nommage permettent d’utiliser un même nom pour désigner plusieurs classes dans des contextes différents. Par exemple, nous pourrions définir notre propre classe string, différente de celle du C++ en utilisant un autre espace de nommage.
Voici les lignes de code qui nous intéressent :
int main()
{
string s1("ABC"); // Ligne A
string* s2 = new string("XYZ"); // Ligne B
cout << s1 << " " << *s2 << endl; // Ligne C
delete s2; // Ligne D
return 0;
}
On reconnait la fonction main qui a le même rôle qu’en langage C. La plupart des éléments du langage C appartiennent aussi au C++.
La ligne A crée une variable s1 dans la pile et place dans cette variable une instance de string représentant la chaîne "ABC". Cette déclaration de la variable s1 appelle un constructeur de la classe string en lui passant en paramètre la chaîne constante "ABC" qui est dans le format de représentation des chaînes du langage C, vue en partie D.
La ligne B crée dans la pile une variable s2 de type pointeur sur string, crée dans le tas une instance de string initialisée avec la chaîne "XYZ", et place l’adresse de cette instance dans la variable s2. Le constructeur de la classe string est appelé par l’instruction new. Cette instruction new est utilisée pour créer des instances de classe dans le tas mais pas pour créer des instances dans la pile.
La ligne C permet l’affichage des chaînes désignées par les variables s1 et s2. La fonction printf du C est utilisable en C++ mais ne permet pas d’afficher des instances de la classe string. La manière standard d’afficher des données en C++ consiste à les envoyer dans le flux de sortie standard cout. La valeur endl représente un passage à la ligne. Comme se sont les instances de string qui doivent être affichées et non leur adresses, l’affichage de l’instance de string pointée par s2 nécessite un "dépointage" noté *s2. En C++, les pointeurs sont identiques à ceux du C et les notations pour leurs déclaration et utilisation sont aussi les mêmes.
La ligne D libère la mémoire occupée par l’instance de string située dans le tas, qui est pointée par s2. Comme en langage C, toute création de bloc mémoire dans le tas entraîne une "dette mémoire" qu’il faut rembourser avant la fin de l’exécution du programme.
La mémoire occupée dans la pile par l’instance de string contenue dans s1 est libérée automatiquement, comme c’est le cas pour toute variable locale.
Examinons ce qui se passe dans la mémoire à l’issue de l’exécution de la ligne B.

La figure ci-dessus utilise une représentation simplifiée d’une instance de string vue comme une sorte de bloc contenant une chaîne. La représentation réelle en mémoire est plus complexe et comporte une ramification dans le tas, y compris si l’instance est dans la pile. Mais on peut utiliser la classe en faisant abstraction de la représentation réelle des données associée à chacune de ses instances.
La représentation réelle, ou concrète, des instances d’une classe nous intéressera lorsque nous seront amené à implémenter cette classe. Mais si elle est correctement implémentée, en respectant les bonnes pratiques de gestion de la mémoire qui seront introduites dans la partie H, nous pourrons raisonner uniquement avec la représentation simplifiée lors de l’utilisation d’une classe.
Une classe comporte généralement des méthodes d’instance permettant d’agir sur ses instances. Une telle méthode s’appelle avec une instance de la classe dans laquelle elle est définie. Voici un exemple avec la méthode d’instance size de la classe string, qui retourne la longueur de la chaîne représentée :
string s1("ABC");
string* s2 = new string("XYZ");
cout << s1.size() << endl; // Ligne A
cout << s2->size() << endl; // Ligne B
En ligne A, la méthode size est appelée avec l’instance de string contenue dans la variable s1. Notez l’utilisation du point : s1.size().
En ligne B, la méthode size est appelée avec l’instance de string pointée par la variable s2. On utilise alors la flèche : s2->size().
Ces notations sont similaires à celles utilisées en C avec les instances de structures, sauf qu’ici elles permettent l’accès à des méthodes et non à des champs (qui représentent des données).
Le langage C++ permet la surcharge des opérateurs. Un opérateur surchargé a un comportement spécifique lorsqu’il est appliqué à des instances de la classe pour laquelle il est surchargé. Nous ne verrons pas comment implémenter des opérateurs surchargés (excepté l’opérateur =) mais nous utiliserons des opérateurs surchargés de la classe string. Voici quelques exemples :
string t = "abc"; // Ligne A
string u = "def"; // Ligne B
t = t + u; // ligne C
u = t + "ghi"; // Ligne D
cout << u << endl;
L’opérateur = de la ligne A (tout comme celui de la ligne B) est surchargé de manière à permettre l’initialisation d’une instance de string avec une chaîne au format C. A gauche, la variable t est de type string alors qu’à droite, la constante littérale "abc" est de type char*. Derrière cette syntaxe simple se cache en fait un mécanisme sophistiqué qui invoque un constructeur de la classe string. Nous y reviendrons plus tard.
L’opérateur + de la ligne C est également surchargé pour permettre la concaténation de deux chaînes. Il s’applique à deux instances de string et a pour résultat une instance de string. L’opérateur = de cette même ligne n’a pas le même rôle que celui des lignes A et B. À gauche et à droite de cet opérateur, il y a des instances de string.
L’opérateur + de la ligne D est également surchargé, mais ce n’est pas le même que celui de la ligne C. Celui-ci permet de concaténer à une chaine représentée par une instance de string (à gauche) une chaine au format C (à droite).
L’affichage produit par l’exécution est :
abcdefghi
Exercice de découverte G.dec.x1
Donnez les lignes de code permettant :
- De créer dans le tas une instance de
stringcontenant la chaine"aaaaa", pointée par une variablessituée dans la pile. - De concaténer la chaine
"bbb"à la chaine pointée parset de placer le résultat dans une variabletde typestringsituée dans la pile.
string* s = new string("aaaaa");
string t = *s + "bbb";
G.dec2 : Classes monolithiques
Prérequis
| Section G.dec1, Parties A et C |
|---|
Objectif
| Rassembler dans une "capsule" plusieurs données et des méthodes permettant d’agir sur ces données. |
|---|
Dans les langages de programmation procéduraux, tels que le langage C, on peut regrouper plusieurs informations dans des structures de données telles que des tableaux et des structures. Des fonctions ou procédures permettent d’exploiter les données ainsi représentées.
Le concept de programmation orientée objet permet de regrouper des structures de données et l’implémentation d’algorithmes permettant de traiter, manipuler, utiliser ces données dans des "capsules" appelée classes. Cette approche simplifie la programmation et permet de produire du code source réutilisable, plus facile à faire évoluer que celui des langages purement procéduraux.
Moyen
| Définir des classes |
|---|
Commençons par un premier exemple : la déclaration d’une classe Point permettant de représenter des points appartenant à un espace à deux dimensions.
class Point
{
private:
// Attributs
double x;
double y;
public:
// Constructeurs
Point();
Point(double x, double y);
// Méthodes d'accès
void setX(double x);
void setY(double Y);
double getX();
double getY();
// Méthode d'affichage
void affiche();
};
Cette déclaration ne définit pas complètement la classe, mais elle donne des informations importantes, à savoir que la classe Point comporte :
- Deux attributs privés
xetyde typedouble. Il s’agit des données de toute instance de la classe. Ces attributs ont un rôle similaire à celui des champs d’une structure en langage C. Parce qu’ils sont privés (mot cléprivate), seules les méthodes de la classePointpeuvent accéder à ces attributs. - Deux constructeur publiques qui permettront d’initialiser les instances de
Pointlors de leur création. L’un des constructeurs n’a pas de paramètre. C’est un constructeur par défaut. L’autre a pour paramètres les coordonnées du point qui sera représenté par l’instance construite. - Des méthodes d’accès qui permettent de lire et de modifier les valeurs des attributs. Ces méthodes, contrairement aux attributs, sont publiques. Elle sont utilisables par des méthodes membres d’autres classes et par des fonctions n’appartenant à aucune classe.
- Une méthode
affichequi permettra d’afficher le contenu d’une instance dePoint.
Après avoir déclaré la classe, il nous faut définir ses constructeur et ses méthodes.
Point::Point()
{
this->x = 0.0;
this->y = 0.0;
}
Point::Point(double x, double y)
{
this->x = x;
this->y = y;
}
void Point::setX(double val)
{
this->x = val;
}
void Point::setY(double val)
{
this->y = val;
}
double Point::getX()
{
return x;
}
double Point::getY()
{
return y;
}
void Point::affiche()
{
cout << "(" << x << "," << y << ")";
}
Dans un projet constitué de plusieurs fichiers, la déclaration de la classe doit être placée dans un fichier d’entête qui pourrait être nommé Point.h et les définitions de ses constructeurs, destructeur (non nécessaire dans notre exemple) et méthodes doivent être placées dans un fichier qui pourrait être nommé Point.cpp. Mais dans un projet minimaliste, il est possible de placer la déclaration et les définitions dans un même fichier.
Dans le constructeur par défaut (sans paramètre), la notation this->x est utilisée. Le mot clé this représente l’adresse l’instance en cours de construction, et this->x permet donc d’accéder à l’attribut x de l’instance en cours de construction. On aurait pu écrire x = 0.0 à la place de this->x = 0.0.
Dans le constructeur à deux paramètres, on retrouve les notations this->x et this->y, mais ici elles sont nécessaires pour distinguer les attributs des paramètres du constructeur qui ont les mêmes noms.
La lecture des définitions des méthodes devrait vous permettre d’en comprendre les rôles.
Voici un exemple d’utilisation de la classe Point et de ses méthodes.
int main()
{
Point w(1.0, 2.0); // Ligne A
w.affiche(); // Ligne B
cout << endl << w.getX() << endl; // Ligne C
w.setY(3.0); // Ligne D
w.affiche(); // Ligne E
return 0;
}
En ligne A, on crée une instance de Point située sur la pile dans une variable w.
En ligne B, on appelle la méthode d’instance affiche de la classe Point pour afficher le contenu de w.
En ligne C, on récupère la coordonnée x du point représenté par w et on l’affiche.
En ligne D, on modifie la coordonnée y du point représenté par w.
Les affichages obtenus sont :
(1,2)
1
(1,3)
Exercice de découverte G.dec.x2
Donnez les lignes de code permettant de créer une instance de Point située dans le tas en utilisant le constructeur par défaut, puis d’assigner la valeur 5.0 à la coordonnée y de du point représenté par cette instance, et enfin d’afficher ce point.
Point* p = new Point();
p->setY(5.0);
p->affiche();
Nous allons maintenant ajouter une nouvelle méthode permettant de déterminer le point situé au milieu du segment déterminé par deux points. Voici une première version :
Point Point::milieu(Point autre)
{
double mx = (this->x + autre.x) / 2.0;
double my = (this->y + autre.y) / 2.0;
return Point(mx,my);
}
Et voici une deuxième version qui a l’avantage d’être indépendante de la représentation des points. Si par exemple les attributs privés représentaient un point en coordonnées polaires et que les méthodes d’accès étaient modifiée de manière à retourner les coordonnées cartésiennes, aucun changement ne serait nécessaire dans la définition de la méthode milieu.
Point Point::milieu(Point autre)
{
double mx = (this->getX() + autre.getX()) / 2.0;
double my = (this->getY() + autre.getY()) / 2.0;
return Point(mx,my);
}
Exercice de découverte G.dec.x3
Donnez les lignes de code permettant de créer deux instances de Point dans la pile, puis de créer une instance de Point représentant le milieu du segment délimité par les deux premiers points, puis d’afficher le résultat.
Point a(1.0,1.0);
Point b(0.0,2.0);
Point c = a.milieu(b);
c.affiche();
Il y a une petite singularité syntaxique lors de la création d’une instance de classe dans la pile avec un constructeur par défaut. Examinons l’exemple suivant :
Point p1; // Ligne A
Point* p2 = new Point(); // Ligne B
Point p3(1.0, 1.0); // Ligne C
Point* p4 = new Point(1.0, 1.0); // Ligne D
Cette singularité se situe sur la ligne A, qui crée une instance de Point située dans la pile. Il n’y a pas de parenthèses, alors que lors de la création d’une instance similaire dans le tas, ligne B, il y a des parenthèses. Dans le cas de l’utilisation d’un constructeur avec paramètres, il y a toujours des parenthèses.
Complément
Si aucun constructeur n’est définit pour une classe, cette classe est pourvue d’un constructeur par défaut implicite (invisible dans le code). Ce constructeur par défaut n’initialise pas les attributs de types primitifs tels que int et double. Il est toutefois possible de donner des valeurs d’initialisation aux attributs en utilisant la syntaxe suivante :
class Point
{
private:
double x{0.0};
double y{0.0};
// etc.
};
Dès lors qu’au moins un constructeur est définit, même s’il ne s’agit pas d’un constructeur par défaut (c’est à dire sans paramètre), il n’y a plus de constructeur par défaut implicite. Si un tel constructeur est nécessaire, alors il faut le définir explicitement.
G.dec3 : Références
Prérequis
| Section G.dec1 et G.dec2 |
|---|
Objectif
| Optimiser l’efficacité des méthodes et constructeurs exploitant des instances de classes |
|---|
Comme les structures du langage C, les classes du C++ supportent nativement le passage en paramètres par copie et l’assignation avec l’opérateur =. Mais la copie d’une instance de classe peut prendre plus de temps CPU et consommer plus de mémoire que la copie de son adresse.
Il est possible d’optimiser l’efficacité de certaines méthodes en leur passant en paramètres des pointeurs sur des instances de classe plutôt que des instances de classes, comme cela peut se pratiquer en C avec les structures et les fonctions, mais il y a une autre possibilité en C++.
Moyen
| Les références |
|---|
Une référence est un pointeur caché. Pointeur parce qu’en mémoire, un référence est représentée par un pointeur, caché parce qu’à l’utilisation, la syntaxe est identique à celle d’un passage de paramètre par copie ou d’une assignation d’instance de classe.
Examinons un exemple basé sur la méthode milieu de la classe Point de la section précédente, que nous renommons milieu1 :
Point Point::milieu1(Point autre)
{
double mx = (this->getX() + autre.getX()) / 2.0;
double my = (this->getY() + autre.getY()) / 2.0;
return Point(mx,my);
}
Il est possible de réaliser une version avec passage du paramètre par pointeur :
Point Point::milieu2(Point* autre)
{
double mx = (this->getX() + autre->getX()) / 2.0;
double my = (this->getY() + autre->getY()) / 2.0;
return Point(mx,my);
}
Mais ont peut aussi réaliser une troisième version utilisant le passage de paramètre par référence :
Point Point::milieu(Point& autre)
{
double mx = (this->getX() + autre.getX()) / 2.0;
double my = (this->getY() + autre.getY()) / 2.0;
return Point(mx,my);
}
Observez attentivement les différences dans le code des trois variantes. L’esperluette & de la troisième version à une signification nouvelle. Elle dit que le paramètre autre est une référence d’instance de Point. Cette référence désigne une variable de type Point et s’utilise comme telle.
Examinons à présent l’utilisation de ces trois variantes :
Point a(1.0,1.0);
Point b(2.0,3.0);
Point m1 = a.milieu1(b); // Ligne A
Point m2 = a.milieu2(&b); // Ligne B
Point m3 = a.milieu(b); // Ligne C
m1.affiche();
m2.affiche();
m3.affiche();
En ligne A, on passe en paramètre une copie de l’instance de Point contenue dans la variable b. Cette instance et sa copie ont chacune une taille de 16 octets.
En ligne B, on passe en paramètre l’adresse de la variable b. Sur la machine utilisée pour mes essais, cette adresse a une taille de 8 octets.
En ligne C, on passe en paramètre la référence de la variable b. La référence est en fait l’adresse de la variable, mais la syntaxe de l’appel est identique à celle utilisée pour un paramètre passé par copie.
En résumé, la variante avec passage de paramètre par référence est aussi efficace que celle avec passage par pointeur, mais avec une syntaxe simplifiée : pas d’esperluette lors de l’appel, pas de flèche pour l’accès aux méthodes d’instance du paramètre dans le code de la méthode.
Exercice de découverte G.dec.x4
Donnez les lignes de code permettant de créer deux instances de Point dans le tas et d’utiliser la méthode milieu pour produire le milieu du segment délimité par ces deux points et placer le résultat dans une variable m située dans la pile. N’oubliez pas qu’à l’utilisation, une méthode qui accepte un paramètre par référence s’utilise comme une méthode qui accepterait ce paramètre par copie.
Point* a = new Point(1.0,1.0);
Point* b = new Point(2.0,3.0);
Point m = a->milieu(*b);
Il ne fallait pas oublier :
- L’utilisation de
newpour créer des instances dans le tas. - Que
newretourne un pointeur vers l’instance construite. - Que l’appel d’une méthode d’instance via l’adresse de cette instance nécessite l’utilisation de la flèche
->. - Que le passage en paramètre par copie, ou par référence, d’une instance via son adresse nécessite une dépointage.
Tout ceci peut paraitre obscur et compliqué en première lecture, mais c’est en fait d’une extrême cohérence. Il faut simplement prendre le temps de comprendre et d’assimiler chaque concept, un par un. N’hésitez pas à faire vos propres essais sur machine, à inventer vos propres expériences.
Complément
| Complément sur les références |
|---|
L’utilisation des références n’est pas limitée aux paramètres de méthodes ou fonctions. Une méthode d’instance peut retourner la référence d’un attribut de la classe à laquelle elle appartient (des exemples seront donné dans la partie G.ent.). Par contre, une méthode ne peut pas retourner la référence d’une de ses variables locales, puisqu’une telle variable n’existe plus lorsque l’exécution de la fonction dans laquelle elle est déclarée se termine.
Des variables de type référence peuvent par ailleurs être déclarées et utilisées. Voici un exemple :
void exemple()
{
Point a(1.0,1.0); // Ligne A
Point& b = a; // Ligne B
b.setY(2.0); // Ligne C
a.affiche();
b.affiche();
}
En ligne A, la variable a est initialisée avec une instance de Point.
En ligne B, la variable b, de type référence sur Point, est initialisée avec la référence de a.
En ligne C, on modifie l’instance de Point référencée par b.
À l’exécution, on obtient l’affichage :
(1,2) (1,2)
Cette modification a impacté l’instance de Point située dans la variable a car a et b désignent la même instance.
G.dec4 : Classes composées
Prérequis
| Sections G.dec1, G.dec2, G.dec3 |
|---|
Objectif
| Modéliser et exploiter des données complexes structurées en plusieurs blocs |
|---|
Moyen
| Définir des classes ayant des attributs de type classe |
|---|
Voici la déclaration d’une classe permettant de représenter des segments constitués de 2 points.
class Segment
{
private:
Point a;
Point b;
public:
Segment(Point& deb, Point& fin);
Segment(double x1, double y1, double x2, double y2);
Point milieu();
void affiche();
};
Les attributs a et b, représentant les extrémités d’un segment, sont des instances de Point.
Deux constructeurs sont déclarés, un permettant l’initialisation du segment créé avec des instances de Point passée par références, et un autre acceptant en paramètre les coordonnées, de type double, des deux extrémités.
Une méthode milieu devra retourner l’instance de Point représentant le milieu d’un segment et une méthode affiche permettra l’affichage d’une instance de Segment.
Des méthodes d’accès pourraient être ajoutées.
Voici la définition du premier constructeur :
Segment::Segment(Point& deb, Point& fin) :
a(deb), b(fin)
{
}
La syntaxe utilisée ici est nouvelle et différente de celle vue avec la classe Point. Les attributs a et b ne sont pas initialisés dans le corps du constructeur, mais par une liste d’initialisation qui fait appel au constructeur en copie implicite de la classe Point.
La notation a(deb) signifie que l’attribut a est initialisé avec une copie de l’instance de Point désignée par deb.
Il est possible d’initialiser les deux attributs dans le corps du constructeur comme ceci :
Segment::Segment(Point& deb, Point& fin)
{
a = deb;
b = fin;
}
Mais cette forme est déconseillée pour l’initialisation d’attributs de type classe car elle peut entraîner, dans certaines situations, une perte de performance, bien que ce ne soit pas le cas ici.
Voici la définition du deuxième constructeur :
Segment::Segment(double x1, double y1, double x2, double y2) :
a(Point(x1,y1)), b(Point(x2,y2))
{
}
Ici encore, une liste d’initialisation est utilisée pour initialiser les attributs représentant les extrémités du segment par appel du constructeur à deux paramètres de la classe Point. L’initialisation des attributs dans le corps du constructeur serait possible, mais entrainerait dans ce cas une perte d’efficacité. En effet, si on écrit…
Segment::Segment(double x1, double y1, double x2, double y2)
{
this->a = Point(x1,y1);
this->b = Point(x2,y2);
}
… alors par exemple lors de l’initialisation de l’attribut a, une instance de Point est créée par le constructeur à deux paramètres de la classe Point, puis recopiée dans l’attribut par l’opérateur d’assignation =, puis détruite (alors que sa copie reste dans l’attribut a). Avec l’utilisation d’une liste d’initialisation, le constructeur de la classe Point crée directement une instance dans l’attribut a.
Ne vous inquiétez pas si vous ne saisissez pas la nuance entre le fonctionnement des deux variantes. Par contre, retenez que lorsque les attributs contiennent des instances de classe, l’utilisation d’une liste d’initialisation est préférable et conseillée.
Voici la définition de la méthode milieu de la classe Segment qui fait appel à la méthode milieu préalablement définie dans la classe Point.
Point Segment::milieu()
{
return a.milieu(b);
}
Exercice de découverte G.dec.x5
Définissez la méthode Segment::affiche() sachant que l’exécution des lignes de code suivantes…
Segment s1(1.0, 2.0, 3.0, 4.0);
s1.affiche();
…doit produire l’affichage :
[(1,2),(3,4)]
void Segment::affiche()
{
cout << "[";
a.affiche();
cout << ",";
b.affiche();
cout << "]" << endl;
}
Complément
Telle que définie précédemment, la classe Segment n’a pas de constructeur par défaut, ni implicite, ni explicite. La présence d’autres constructeurs annule l’existence d’un constructeur par défaut implicite. On peut bien sur ajouter un constructeur par défaut explicite. Celui-ci permet d’initialiser les deux attributs avec le constructeur par défaut de la classe Segment :
Segment::Segment()
{
}
Il n’est pas nécessaire de mettre du code car les attributs de type classe (dans ce cas particulier, la classe Point) sont initialisés implicitement avec les constructeur par défaut de leur classe.
On pourrait également écrire :
Segment::Segment() :
a(), b()
{
}
G.dec5 : La classe standard vector
Prérequis
| Sections précédentes : G.dec1 à G.dec4 |
|---|
Objectif
| Exploiter des listes ordonnées de données d’un même type |
|---|
En langage C comme dans de nombreux autres langages de programmation, les tableaux permettent de représenter des listes de données de même types et d’accéder à ces données à l’aide d’un indice qui indique leurs position dans la liste.
Nous avons vu que les tableaux du langage C sont très rudimentaires puisqu’ils sont implémentés comme de simples blocs mémoire accessibles via des pointeurs. L’utilisation de tels tableaux est très peu sécurisée et comporte certaines limitations, telle que l’impossibilité de copier directement le contenu d’un tableau dans un autre avec l’opérateur d’assignation =.
Un moyen plus sûr et plus pratique pour représenter et exploiter une collection de données de même type serait bienvenu.
Moyen
| La classe standard std::vector |
|---|
Les instances de la classe standard std::vector représentent des listes de valeurs d’un même type scalaire (int, double etc.) ou d’instances d’une même classe. Contrairement à un tableau, une liste représentée par un vecteur est extensible. On peut augmenter sa taille en insérant de nouveaux éléments à la fin, au début ou au milieu.
Remarque importante : Toutes les possibilités et toutes les subtilités de la classe std::vector ne seront pas présentées. Par exemple, les itérateurs et l’insertion d’éléments dans un vecteur ne seront pas abordés.
Voici un exemple de déclarations de vecteurs d’instances de Points.
Point w(1.0,2.0);
vector<Point> v1; // Ligne A
vector<Point> v2(5); // Ligne B
vector<Point> v3(3,w); // Ligne C
En ligne A, un vecteur vide est créé dans la pile. En réalité, l’instance créée comporte une ramification dans le tas, mais qui est complètement transparente lors de l’utilisation, c’est à dire qu’elle se comporte comme une instance de classe monolithique qui serait entièrement stockée dans la pile. En particulier, la mémoire occupée par sa ramification dans le tas sera automatiquement libérée lorsque la variable v1 sera détruite.
En ligne B, un vecteur contenant 5 instances de Point est créé. Chacune des instances placées dans le vecteur est initialisée avec le constructeur par défaut de la classe Point. Si la classe Point n’avait pas de constructeur par défaut, une erreur serait produite à la compilation.
En ligne C, un vecteur contenant 3 copies de l’instance de Point contenue dans la variable w est créée.
Il est également possible d’initialiser une instance de vecteur en utilisant des accolades, comme pour un tableau. Voici deux exemples qui ont exactement le même effet : créer une instance de vector contenant deux points.
vector<Point> vec1{{1.0,1.0}, {2.0,3.0}};
vector<Point> vec2{Point(1.0,1.0), Point(2.0,3.0)};
Nous allons maintenant voir comment ajouter des éléments à la fin d’un vecteur et comment retirer l’élément situé en fin d’un vecteur. Chacune de ces opérations change la taille du vecteur, qui peut être obtenue grâce à la méthode size.
v1.push_back(w); // Ligne A
v2.pop_back(); // Ligne B
v2.push_back(w); // Ligne C
cout << v1.size() << endl;
cout << v2.size() << endl;
En ligne A, une copie de l’instance de Point située dans la variable w est ajoutée à la fin du vecteur situé dans la variable v1.
En ligne B, le dernier élément du vecteur situé dans la variable v2 est supprimé.
En ligne C, une copie de l’instance de Point située dans w est ajoutée à la fin du vecteur situé dans la variable v2.
Les deux dernières lignes affichent les tailles des deux vecteurs :
1
5
Exercice de découverte G.dec.x6
Donnez la liste de points contenus dans les vecteurs situés dans les variables v1 et v2 à l’issue de l’exécution des lignes de code suivantes :
Point w(1.0,2.0);
vector<Point> v1;
vector<Point> v2(5);
v1.push_back(w);
v2.pop_back();
v2.push_back(w);
Contenu du vecteur situé dans v1 :
(1.0,2.0)
Contenu du vecteur situé dans v2 :
(0.0,0.0),(0.0,0.0),(0.0,0.0),(0.0,0.0),(1.0,2.0)
On peut accéder aux éléments d’un vecteur en lecture et écriture avec la même notation à base de crochets que pour un tableau. Voici un exemple d’utilisation dans une fonction ayant pour rôle d’afficher un vecteur de points :
void printVectPoint(vector<Point>& vect)
{
for(int i=0; i<vect.size(); i++)
{
vect[i].affiche();
}
cout << endl;
}
Il ne s’agit pas d’une méthode, mais d’une fonction n’appartenant à aucune classe qui accepte en paramètre la référence d’une instance de la classe vector<Point>. Le passage par référence est utilisé ici pour améliorer l’efficacité. Comme le vecteur n’est pas modifié, un passage par copie aurait été possible.
Exercice de découverte G.dec.x7
Donnez les lignes de code permettant d’appeler la fonction printVectPoint pour afficher les contenus des vecteurs situés dans les variables v1 et v2.
printVectPoint(v1);
printVectPoint(v2);
Exercice de découverte G.dec.x8
Donnez les lignes de code permettant de réaliser les actions suivantes :
- Déclarer une variable
tabcontenant un vecteur d’entiers contenant 5 fois la valeur 1, - Ajouter la valeur 2 à la fin en utilisant la méthode
push_back, - Remplacer la première valeur par 3 en utilisant les crochets.
- Afficher tous les éléments du vecteur à l’aide d’une boucle
for.
Le vecteur est créé et initialisé par cette déclaration :
vector<int> tab(5,1);
Voici les trois premières lignes. Il manque la boucle d’affichage.
vector<int> tab(5,1);
tab.push_back(2);
tab[0] = 3;
for(int i=0; i<tab.size(); i++)
{
cout << tab[i] << " ";
}
cout << endl;
Compléments
| Quelques méthodes utiles de la classe vector |
|---|
Nous prendrons comme exemple un vecteur de points :
vector<Point> vec(5);
Accès au dernier élément d’un vecteur :
reference back();
Exemple d’utilisation :
// Modifie la coordonnée x du dernier point du vecteur
vect.back().setX(5.3);
Équivalent à :
vect[vect.size()-1].setX(5.3);
Suppression des éléments d’un vecteur
void clear();
Exemple d’utilisation :
vect.clear();
cout << vect.size(); // Affiche 0
Augmentation de la capacité
La taille d’un vecteur augmente automatiquement lorsqu’on lui ajoute des éléments, mais cette opération a un certain coût. Pour améliorer l’efficacité de l’ajout d’éléments, un vecteur dispose d’une capacité de stockage qui peut être plus grande que son nombre d’éléments. Quand le nombre d’éléments stockés dans un vecteur atteint sa capacité, celle-ci est augmentée automatiquement d’une valeur fixée par un algorithme interne à la classe vector.
La méthode suivante permet de fixer une capacité, ce qui peut permettre d’améliorer l’efficacité des ajouts lorsqu’on connait le nombre d’éléments qui seront, à terme, stockés dans le vecteur.
void reserve(size_type count);
Exemple d’utilisation :
vect.reserve(1000);
Cette méthode n’ajoute aucun élément au vecteur. Elle réserve juste une certaine capacité de stockage pour éviter une perte de performance due à des augmentations successives cette capacité.
Modification de la taille
La méthode suivante modifie la taille d’un vecteur, c’est à dire le nombre d’éléments qu’il contient.
void resize(size_type new_size);
void resize(size_type new_size, Type value);
Dans le cas d’un agrandissement, la première variante utilise le constructeur par défaut de la classe des éléments du vecteur pour initialiser les éléments ajoutés, alors que la deuxième variante ajoute des copies de value.
Exemple d’utilisation :
vect.resize(20);
Notre vecteur contenait initialement 5 instances de Point. Après redimensionnement, il en contient 20. Les 15 instances de Point ajoutées ont été initialisées par le constructeur par défaut (sans paramètre) de la classe Point.
Exercice de découverte G.dec.x9
Donnez la ligne de code permettant d’augmenter la taille du vecteur contenu dans la variable vect à 30 en ajoutant des instances de Point représentant des points de coordonnées (3.5,5.6). Vous devez utliser la méthode resize.
Point p(3.5,5.6);
vect.resize(30,p);
G.dec6 : Classes ramifiées et destructeurs
Prérequis
| Sections G.dec1 à G.dec6 |
|---|
Objectif
| Éviter les fuites mémoire |
|---|
Jusqu’à maintenant, nous n’avons pas implémenté de destructeur dans nos classes. La raison est qu’un destructeur implicite est implémenté par le compilateur lorsqu’aucun destructeur explicite n’est ajouté à une classe. Ce destructeur implicite libère la mémoire occupée par l’instance de la classe pour laquelle il est appelé, après avoir appelé automatiquement les destructeurs des instances contenues dans ses attributs, si applicable.
Ces destructeurs implicites suffisent pour libérer toute la mémoire occupée par les instances de classes sans ramification dans le tas, ce qui est le cas des classes Point et Segment données en exemple.
Mais lorsqu’une classe a des attributs de type pointeur sur une instance de classe, les choses se compliquent. Il devient nécessaire de d’implémenter un destructeur explicite.
Moyen
| Définir un destructeur explicite |
|---|
Nous allons commencer par faire quelques expériences avec la classe Segment définie précédemment, dans le but de voir quand le constructeur est appelé automatiquement et quand il est nécessaire de l’appeler explicitement.
Ajoutons un destructeur dans la classe Segment, dont la nouvelle déclaration est :
class Segment
{
private:
Point a;
Point b;
public:
Segment(Point& deb, Point& fin);
Segment(double x1, double y1, double x2, double y2);
Point milieu();
void affiche();
~Segment(); // Destructeur
};
Dans la définition du destructeur, on met un affichage dont le but est purement pédagogique :
Segment::~Segment()
{
cout << "Destruction instance Segment " << this << endl;
}
Si on exécute la fonction suivante…
void exemple1()
{
Segment s(1.0,1.0,3.0,3.0);
s.affiche();
}
…on obtient l’affichage :
[(1,1),(3,3)]
Destruction instance Segment 0x7ffe697eca10
Le destructeur a été appelé automatiquement à l’issue de l’exécution de la fonction dans laquelle la variable s a été déclarée. L’adresse affichée est celle où est implantée (dans la pile) l’instance de Segment concernée. Elle change à chaque exécution du programme.
Si on exécute la fonction suivante…
void exemple2()
{
Segment s(1.0,1.0,3.0,3.0);
Segment* p = new Segment(1.5,0.5,2.0,2.0);
s.affiche();
p->affiche();
}
…on obtient l’affichage :
[(1,1),(3,3)]
[(1.5,0.5),(2,2)]
Destruction instance Segment 0x7ffe31cc9730
On constate que la deuxième instance de Point, qui a été créée dans le tas grâce à l’instruction new, n’a pas été détruite.
Les instances créées dans le tas ne sont pas automatiquement détruites. La création de telles instances occasionne une "dette mémoire" qu’il faudra rembourser en utilisant delete pour les détruire.
La destruction d’une instance (par delete) ne se fait pas nécessairement dans la fonction où cette instance a été créée (par new). Mais dans notre exemple simple, c’est ce que nous allons faire :
void exemple6()
{
Segment s(1.0,1.0,3.0,3.0);
Segment* p = new Segment(1.5,0.5,2.0,2.0);
s.affiche();
p->affiche();
delete p;
}
L’affichage obtenu est :
[(1,1),(3,3)]
[(1.5,0.5),(2,2)]
Destruction instance Segment 0x5573559f92c0
Destruction instance Segment 0x7ffe11f740b0
Les deux instances ont été détruites par appel du destructeur de la classe Segment. Le destructeur de l’instance située dans la pile a été appelé automatiquement. Celui de l’instance situées dans le tas a été appelé explicitement.
Mais nous n’avons rien mis dans ce destructeur, excepté un affichage. En effet, le mécanisme de destruction est ajouté de manière implicite au destructeur et aucun code spécifique n’est nécessaire… tant que la classe concernée n’a pas de ramification dans le tas.
Dans un but purement pédagogique, nous allons déclarer et définir une nouvelle variante de la classe Segment avec ramification dans le tas :
class Seg
{
private:
Point* a;
Point* b;
public:
Seg(Point& deb, Point& fin);
Seg(double x1, double y1, double x2, double y2);
Point milieu();
void affiche();
~Seg();
};
Cette classe a les mêmes méthodes que la classe Segment définie précédemment, mais ses attributs sont de type pointeur sur Point et cela change beaucoup de choses. Pour s’en convaincre, on peut observer la représentation en mémoire d’une instance de Segment, non ramifiée…

…et d’une instance de Seg :

Une instance de Segment est monolithique, i.e. constituée d’un seul bloc de mémoire. Une instance de Seg est constituée de trois blocs de mémoire : un socle, qui peut être situé dans la pile ou dans le tas, et deux blocs, nécessairement situés dans le tas, qui seront créé à l’aide de new par les constructeurs de Seg. Ces deux blocs devront être explicitement détruits par des appels à delete dans le destructeur de Seg. De fait il devient nécessaire de définir un destructeur explicite dans la classe Seg.
Voici les définitions des constructeurs de la classe Seg :
Seg::Seg(Point& deb, Point& fin)
{
this->a = new Point(deb);
this->b = new Point(fin);
}
Seg::Seg(double x1, double y1, double x2, double y2)
{
this->a = new Point(x1,y1);
this->b = new Point(x2,y2);
}
Dans la première version, le constructeur en copie de la classe Point (qui est défini implicitement car Point est une classe sans ramification dans le tas) est appelé. Dans la deuxième version, le constructeur à deux paramètres de la classe Point est appelé. Dans les deux cas, les instances de Point sont créée dans le tas par l’opérateur new.
L’utilisation de new dans le constructeur, qui correspond à la création d’une ramification dans le tas, implique la définition d’un destructeur qui détruira cette ramification.
Exercice de découverte G.dec.x10
Donnez la définition de la méthode Seg::milieu. Pour mémoire, la définition de Segment::milieu était :
Point Segment::milieu()
{
return a.milieu(b);
}
Point Seg::milieu()
{
return a->milieu(*b);
}
Le point . a été remplacé par la flèche -> pour l’appel de la méthode Point::milieu parce que a désigne une adresse d’instance de Point.
Le paramètre de la méthode Point::milieu est de type Point& et s’utilise comme un paramètre de type Point. Or l’attribut b n’est pas de type Point, mais de type Point*. Lors de l’appel de la méthode, on doit donc utiliser l’opérateur de "dépointage" *.
La méthode d’affichage de Seg est définie comme suit :
void Seg::affiche()
{
cout << "[";
a->affiche();
cout << ",";
b->affiche();
cout << "]" << endl;
}
Voici la définition du destructeur de la classe Seg :
Seg::~Seg()
{
delete this->a;
delete this->b;
}
Il contient le code permettant dé détruire les instances de Point pointées par les deux attributs a et b.
La classe Seg s’utilise exactement comme la classe Segment, mais en l’état, son utilisation peut conduire à des effets de bord dans certaines situations que nous ne développerons pas dans ici, mais qui seront abordées dans la partie H. Cette classe Seg présente donc des inconvénients et pas vraiment d’avantages par rapport à la classe Segment.
Exercice de découverte G.dec.x11
L’exécution des lignes de code suivantes…
cout << sizeof(Point) << endl;
cout << sizeof(Point*) << endl;
…produisent l’affichage :
16
8
Tentez de déterminer les affichage produits par les deux lignes de code suivantes :
cout << sizeof(Segment) << endl;
cout << sizeof(Seg) << endl;
32
16
Une instance de Segment contient deux instances de Point occupant chacune 16 octets en mémoire, alors qu’une instance de Seg contient deux pointeurs occupant chacun 8 octets en mémoire.
G.dec7 : À propos des tableaux au format C
Cette partie ne sera pas incluse dans les évaluations mais ouvre la porte à une programmation de plus bas niveau en C++, c’est à dire la réalisation de classes et programmes n’utilisant pas les classes standards telles que string et vector.
Prérequis
| Parties C, E, et sections G.dec1 à G.dec6 |
|---|
Objectif
| Créer et utiliser des tableaux de bas niveau en C++ |
|---|
Les tableaux au format C sont de simples blocs de mémoire, désignés par des pointeurs. L’intérêt d’une représentation aussi rudimentaire est d’optimiser l’efficacité de leur utilisation en termes d’espace mémoire et de temps CPU.
Il est possible d’utiliser une telle représentation en C++.
Moyen
| Déclarations de tableaux de bas niveau |
|---|
Les tableaux situés dans la pile ou les tableaux de tailles fixe utilisés comme attributs d’une classe se déclarent exactement comme en langage C.
On peut, par exemple, créer un tableau d’instances de Point comme ceci :
Point tab[3];
Contrairement à ce qui ce passe en langage C, en C++ tout tableau est initialisé. Dans le cas ou aucune initialisation explicite n’est réalisée (comme dans l’exemple ci-dessus), les objets contenus dans le tableau sont initialisés avec le constructeur par défaut de la classe concernée.
Les tableaux dynamiques doivent être créés avec l’opérateur new. Voici un exemple :
Point* t = new Point[3];
Ils sont initialisés avec le constructeur par défaut de la classe concernée. Il occasionnent une dette mémoire qui doit être remboursée ultérieurement en utilisant l’opérateur delete[] (avec des crochets vides).
delete[] t;
Activité d’entraînement G.ent
Cette activité est essentielle. C’est grâce à elle que vous apprendrez vraiment à comprendre et utiliser les notions vues précédemment. Elle se décompose en plusieurs itérations : ent1, ent2, etc.
Vous devez réaliser au moins une itération et évaluer votre niveau de réussite par une valeur entre 1 et 4 selon les critères habituels. L’itération que vous avez traité le plus récemment est appelée itération courante. On appelle itération suivante celle qui suit l’itération courante, excepté si l’itération courante est la dernière disponible, auquel cas l’itération suivante est la première itération.
Si le résultat est 1, vous devrez traiter à nouveau l’activité de découverte précédente, en laissant passer au moins une nuit, avant de revenir à cette activité d’entraînement en réalisant à nouveau l’itération courante. Vous devez aussi essayer d’identifier les points de blocage et demander à votre enseignant de vous aider à les surmonter.
Si le résultat est 2, vous devrez d’abord comprendre ce qui vous a conduit à des erreurs et / ou ce qui vous a bloqué. Si vous avez des doutes, des difficultés, essayez de trouver les réponses dans les présentations et explication de l’activité de découverte précédente et demandez toute l’aide nécessaire à votre enseignant. Ensuite, vous devrez réaliser l’itération suivante de l’activité d’entraînement actuelle après un délai d’au moins deux jours et d’au plus une semaine.
Si le résultat est 3, vous devrez revenir traiter l’itération suivante après un délai de plusieurs semaines.
En traitant les exercices, vous devrez considérer que les paramètres des fonctions ont des valeurs correctes. Il ne vous est pas demandé de vérifier si certaines valeurs sont aberrantes au regard de ce que demande l’énoncé. Par exemple, si un paramètre doit être positif pour que le traitement demandé soit possible, vous considérerez que la fonction sera appelée avec une valeur positive de ce paramètre.
Vous pouvez utiliser un ordinateur pour tester vos solutions et les corriger en cas de comportement inattendu. C’est même recommandé, à condition de commencer par réfléchir avant de vous jeter sur le clavier. Si vous pensez avoir une solution différente de celle proposée, ce qui peut arriver souvent, vous ne devez en aucun cas rester dans le doute. Vous devez vérifier si votre solution est correcte ou non, soit en testant votre solution avec un ordinateur, soit en demandant à une personne enseignante.
Itération G.ent1
Exercice d’entrainement G.ent1.1
Réalisez une classe Date représentant une date constituée d’un jour, d’un mois et d’une anné. Cette classe doit disposer
- d’un constructeur par défaut permettant de créer une instance représentant le premier janvier 1900,
- d’un constructeur acceptant en paramètre le jour, le mois et l’année de l’instance à créer,
- de méthodes d’accès permettant de lire et modifier le jour, le mois et l’année,
- d’une méthode
affichepermettant d’afficher l’instance courantre (l’instance avec laquelle la méthode est appelée) dans le format1/1/1900.
Donnez d’abord la déclaration de la classe.
class Date
{
private:
int jour;
int mois;
int annee;
public:
Date();
Date(int j, int m, int a);
int getJour();
int getMois();
int getAnnee();
void setJour(int j);
void setMois(int m);
void setAnnee(int a);
void affiche();
};
Définissez maintenant les deux constructeurs.
Voici les versions avec liste d’initialisation :
Date::Date() :
jour(1), mois(1), annee(1900)
{
}
Date::Date(int j, int m, int a) :
jour(j), mois(m), annee(a)
{
}
Et les versions avec initialisation dans le corps :
Date::Date()
{
jour = 1; mois = 1; annee = 1;
}
Date::Date(int j, int m, int a)
{
jour = j; mois = m; annee = a;
}
Je ne pense pas qu’il y ait une différence d’efficacité entre les deux versions car les attributs ne contiennent pas des instances de classes mais de simples données de type int.
Définissez maintenant les méthode d’accès.
int Date::getJour() {return jour;}
int Date::getMois() {return mois;}
int Date::getAnnee() {return annee;}
void Date::setJour(int j){jour = j;}
void Date::setMois(int m){mois = m;}
void Date::setAnnee(int a){annee = a;}
Maintenant la méthode d’affichage.
void Date::affiche()
{
cout << getJour() << "/" << getMois() << "/" << getAnnee();
}
Définissez une fonction test_Date qui réalise les actions suivantes :
- Création d’une instance de
Datedans la pile avec le constucteur par défaut. Cette instance doit être placée dans une variabled1. - Création d’une instance de
Datedans le tas, initialisée avec le constructeur à 3 paramètres pour représenter le 28 février 2022. L’adresse de cette instance doit être placée dans une variabbled2. - Modification de l’année de la date désignée par
d1pour lui donner la vaelur 2022. - Affichage des dates désignées par
d1etd2.
L’exécution de cette fonction ne devra provoquer aucune fuite mémoire.
void test_Date()
{
Date d1;
Date* d2 = new Date(28, 2, 2022);
d1.setAnnee(2022);
d1.affiche();
cout << endl;
d2->affiche();
delete d2;
}
Exercice d’entrainement G.ent1.2
Ajoutez à la classe Date une fonction…
int Date::compare(Date & autre);
…permettant de comparer la date courante avec une autre date et qui retourne :
- 0 si les deux date sont identiques,
- un entier négatif si la date courante est antérieure à l’autre date,
- sinon une valeur positive.
Essayez de produire un code aussi simple que possible.
Voici une version utilisant les méthodes d’accès.
int Date::compare(Date& autre)
{
if(this->getAnnee() != autre.getAnnee())
{
return this->getAnnee() - autre.getAnnee();
}
else if(this->getMois() != autre.getMois())
{
return this->getMois() - autre.getMois();
}
else
{
return this->getJour() - autre.getJour();
}
}
Un version avec accès direct au attributs, c’est à dire dans laquelle on remplacerait getAnnee par annee, getMois par mois, etc., compile et fonctionne parfaitement. Cependant elle a un incovénient en terme de maintenabilité du code. En effet, si on change la représentation d’une date ou même le nom des attributs, mais en adaptant en conséquence les méthodes d’accès, toutes les autres méthodes utilisant ces méthodes d’accès continueront de fonctionner, alors qu’avec un accès direct aux attributs, il faudra modifier toutes les méthodes de la classes pour retrouver un fonctionnement cohérent.
On change la représentation d’une date dans la classe Date. Au lieu de la représenter par trois entiers, on la représente par un seul entier $j + 100 m + 10000 a$, avec $a$ l’année, $m$ le mois et $j$ le jour. Par exemple le 28 février 2022 sera représenté par l’entier 20220000 + 200 + 28 = 20220228.
La nouvelle classe a donc un unique attribut privé que nous nommerons code.
On ajoute une nouvelle méthode d’accès :
void Date::setAll(int j, int m, int a)
{
code = 10000*a + 100*m + j;
}
Donnez les nouvelles méthodes d’accès getAnnee, getMois, getJour, setAnnee, setMois, setJour qui permettent aux méthodes qui accédaient aux attributs uniquement avec les méthodes d’accès de continuer à fonctionner sans aucune modification. Vous pouvez utiliser la méthode setAll pour simplifier et clarifier votre code.
int Date::getJour() {return code%100;}
int Date::getMois() {return (code/100)%100;}
int Date::getAnnee() {return code/10000;}
void Date::setJour(int j)
{
setAll(j, getMois(), getAnnee());
}
void Date::setMois(int m)
{
setAll(getJour(), m, getAnnee());
}
void Date::setAnnee(int a)
{
setAll(getJour(), getMois(), a);
}
Mais puisque nous avons changé les attributs, il faut aussi changer les constructeurs. Définissez le nouveau constructeur par défaut et le nouveau constructeur à trois paramètres de manière aussi classe élégante que possible.
Date::Date()
{
setAll(1, 1, 1900);
}
Date::Date(int j, int m, int a)
{
setAll(j, m, a);
}
À présent (sauf si j’ai laissé une coquille dans les solutions proposées) les méthodes affiche et compare fonctionnent comme avant sans aucun changement de leur code.
Mais il est possible de simplifier considérablement la méthode compare. Proposez une solution.
Le codage utilisé pour représenter les dates a une propriété très intéressante : une date est antérieure à une autre si et seulement si son code est inférieur à celui de l’autre date. Bien sur, deux dates sont identiques si et seulement si leur codes sont égaux.
int Date::getCode() {return code;}
int Date::compare(Date& autre)
{
return this->getCode() - autre.getCode();
}
Exercice d’entrainement G.ent1.3
On définit une classe Moment représentant une heure de la journée spécifiée avec une résolution d’une minute.
class Moment
{
private:
int heure;
int min;
public:
Moment();
Moment(int h, int m);
int getHeure();
int getMin();
void setHeure(int h);
void setMin(int m);
void affiche();
};
Moment::Moment() :
heure(0), min(0)
{
}
Moment::Moment(int h, int m) :
heure(h), min(m)
{
}
int Moment::getHeure() {return heure;}
int Moment::getMin() {return min;}
void Moment::setHeure(int h)
{
heure = h;
}
void Moment::setMin(int m)
{
min = m;
}
void Moment::affiche()
{
cout << getHeure() << ":" << getMin();
}
Vous devez définir une classe Creneau qui représente un créneau situé entre deux moments d’une journée. Par exemple, un créneau peut être de 16h30 à 17h00 le 6 juillet 2021.
Voici la déclaration de la classe :
class Creneau
{
private:
Date date;
Moment deb;
Moment fin;
public:
Creneau();
Creneau(Date d, Moment deb, Moment f);
Date getDate();
Moment getDeb();
Moment getFin();
void setDate(Date& d);
void setDeb(Moment& m);
void setFin(Moment& m);
void affiche();
int duree();
};
Vous devez donner les définitions des constructeurs.
Creneau::Creneau()
{
}
Creneau::Creneau(Date date, Moment d, Moment f) :
date(date), deb(d), fin(f)
{
}
Le premier constructeur peut paraître bizarre parce qu’il n’a pas de code. En fait, s’il n’y a pas d’initialisation explicite des attibuts de la classe, alors il sont automatiquement initialisés avec les constructeurs par défaut des classes concernées. L’attribut date est initialisé avec le constructeur par défaut de la classe Date. L’attribut deb est initialisé avec le constructeur par défaut de la classe Moment, etc.
Donnez les définitions des méthodes d’accès.
Date Creneau::getDate() {return date;}
Moment Creneau::getDeb() {return deb;}
Moment Creneau::getFin() {return fin;}
void Creneau::setDate(Date& d)
{
date = d;
}
void Creneau::setDeb(Moment& m)
{
deb = m;
}
void Creneau::setFin(Moment& m)
{
fin = m;
}
Donnez la définition de la méthode affiche qui doit produire un affichage ressemblant à ceci :
28/2/2022 [14:15..15:30]
void Creneau::affiche()
{
date.affiche();
cout << " [";
deb.affiche();
cout << "..";
fin.affiche();
cout << "] ";
}
Puis la définition de la méthode duree qui retourne la durée d’un créneau exprimée en minutes.
int Creneau::duree()
{
int t1 = deb.getHeure()*60 + deb.getMin();
int t2 = fin.getHeure()*60 + fin.getMin();
return t2-t1;
}
Vous devez définir une méthode de test qui réalise les actions suivantes :
- Création dans la pile d’une instance de
Creneaucorrespondant au 28 février 2022 de 14h15 à 15h30. - Affichage de ce créneau.
- Affichage de la durée du créneau.
- Création dans le tas d’une copie de l’instance de
Creneaucréée à l’étape 1. Vous devez utiliser le constructeur en copie de la classeCreneau. Pour mémoire, toute classe dispose d’une constructeur en copie implicite qui fonctionne bien dans le cas des classe monolithiques. - Affichage de l’instance de
Creneausituée dans le tas créée à l’étape 4. - Libération de la mémoire.
void test_Creneau()
{
Creneau p1(Date(28,2,2022), Moment(14,15), Moment(15,30));
p1.affiche();
cout << endl << p1.duree() << endl;
Creneau* p2 = new Creneau(p1);
p2->affiche();
}
On exécute le code suivant :
Creneau cr;
cr.getDate().setAnnee(2023);
cr.affiche();
L’affichage obtenu est :
1/1/1900 [0:0..0:0]
Pourtant, cr.getDate() retourne la date du créneau et setAnnee a pour rôle d’en modifier l’année. Pourquoi l’année de la date du créneau désigné par cr n’a-t-elle pas été modifée ?
La méthode getDate retourne une copie de l’instance de Date contenue dans l’attribut date. Modifier l’année de cette copie ne change pas la date désignée par l’attribut Date.
Peut-on modifier la méthode getDate pour que les trois lignes de code présentées plus haut aient pour effet l’affichage ci dessous ?
1/1/2023 [0:0..0:0]
Oui, voici la nouvelle version :
Date& Creneau::getDate() {return date;}
La variante retourne une référence de l’attribut date, à partir de laquelle il est possible de modifier l’attribut.
Exercice d’entrainement G.ent1.4
Dans cet exercice, nous réutiliserons la classe Creneau de l’exercice précédent dans une version où les méthodes d’accès en lecture retournent les références des attributs lus.
class Creneau
{
private:
Date date;
Moment deb;
Moment fin;
public:
Creneau();
Creneau(Date d, Moment deb, Moment f);
Date& getDate();
Moment& getDeb();
Moment& getFin();
void setDate(Date& d);
void setDeb(Moment& m);
void setFin(Moment& m);
void affiche();
int duree();
};
Nous introduisons une nouvelle classe Planning permettant de représenter une liste de créneaux.
class Planning
{
private:
vector<Creneau> data;
public:
void add(Creneau& cr);
void add(int j, int m, int a, int hd, int md, int dur);
void affiche();
int size();
Creneau& getCreneau(int i);
};
Cette classe a un constructeur par défaut implicite qui initialise l’attribut data avec le constructeur par défaut de la classe vector, qui crée un vecteur vide. Il n’est donc pas nécessaire de définir un constructeur par défaut explicite.
Définissez la méthode add à un paramètre qui ajoute un nouveau créneau dans le vecteur data.
void Planning::add(Creneau& cr)
{
data.push_back(cr);
}
Définissez la méthode add à 6 paramètres qui ajoute un nouveau créneau définit par le jour j, le mois m, l’année a, le moment du début spécifié par hd (heure) et md (minutes), et la durée dur exprimée en minutes. Il faudra déterminer le moment de fin en fonction de hd, md et dur.
L’indice concerne la manière de calculer le moment de fin.
Pour calculer l’heure:minute de fin à partir de l’heure:minute de début, on peut convertir en minutes le moment de début, puis ajouter la durée en minutes, et enfin convertir le résultat en heure:minute.
void Planning::add(int j, int m, int a, int hd, int md, int dur)
{
int fin = hd*60 + md + dur;
int hf = fin/60;
int mf = fin%60;
Creneau cr(Date(j,m,a), Moment(hd,md), Moment(hf,mf));
data.push_back(cr);
}
Définissez les deux méthodes size et getCreneau.
int Planning::size() {return data.size();}
Creneau& Planning::getCreneau(int i)
{
return data[i];
}
Définissez la méthode affiche. Elle doit afficher tous les créneaux du planning.
void Planning::affiche()
{
int n = size();
for(int i=0; i<n; i++)
{
getCreneau(i).affiche();
cout << endl;
}
}
Donnez les lignes de code permettant de réaliser les actions suivantes :
- Déclaration d’une variable
crde typeCreneauinitialisée avec créneau28/2/2022 [14:15..15:30]. - Déclaration d’une variable
pde typePlanninginitialisée avec le constructeur par défaut de la classePlanning. - Ajout du créneau désigné par
cr, deux fois de suite, au planning désigné parp. - Modification du deuxième créneau du planning : le mois doit prendre la valeur 3 et l’heure de fin doit prendre la valeur 16.
- Ajout au planning, en utilisant la méthode
addà 6 paramètres, du créneau de 60 minutes commençant le 1/3/2022 à 10h15. - Affichage du planning.
Creneau cr(Date(28,2,2022), Moment(14,15), Moment(15,30));
Planning p;
p.add(cr);
p.add(cr);
cout << endl;
p.getCreneau(1).getDate().setMois(3);
p.getCreneau(1).getFin().setHeure(16);
p.add(1,3,2022,10,15,60);
p.affiche();
Itération G.ent2
Exercice d’entrainement G.ent2.1
En logique propositionnelle, on appelle littéral l’association d’un symbole (nom, identificateur…) et d’un signe. Voici des exemples de littéraux en notation mathématique :
- Littéraux positifs : $\text{a}, \text{alpha}, \text{rouge}$.
- Littéraux négatifs : $\neg \text{a}, \neg \text{beta}, \neg \text{bleu}$
Pour faciliter les affichages à l’écran, nous utiliserons les notations suivantes :
- Littéraux positifs :
+a,+alpha,+rouge. - Littéraux négatifs :
-a,-alpha,-vert.
Voici la déclaration de la classe Litteral permettant de représenter des littéraux.
class Litteral
{
private:
string id;
bool signe;
public:
Litteral(int signe, const string& id);
void affiche();
bool getSigne();
string getId();
bool egal(Litteral& autre);
};
Le type bool permet de représenter les valeur Booléennes avec la même convention qu’en langage C. On pourrait utiliser int à la place. Les valeurs true et false sont également utilisables en C++. Elles représentent les entiers 1 et 0.
Donnez la définition du constructeur à deux paramètres. Le type const string& indique que le deuxième paramètre est la référence d’une instance de string et que cette instance ne sera pas modifiée.
Litteral::Litteral(int signe, const string& id) :
id(id), signe(signe)
{
}
Donnez les définitions des méthodes affiche, getSigne et getId.
void Litteral::affiche()
{
if(signe) cout << "+" << id << " ";
else cout << "-" << id << " ";
}
bool Litteral::getSigne()
{
return signe;
}
string Litteral::getId()
{
return id;
}
Donnez la définition de la méthode egal. Cette méthode doit retourner true si et seulement si le littéral courant (représenté par l’instance de Litteral avec laquelle la méthode est appelée) est identique (même signe et même nom) que celui représenté par autre.
bool Litteral::egal(Litteral &autre)
{
return ((signe==autre.getSigne()) && (id==autre.getId()));
}
Donnez les lignes de code permettant de réaliser les actions suivantes :
- Déclarer une variable
winitialisée avec une instance deLitteralreprésentant le littéral-x1, située dans la pile. - Déclarer une variable
upointant une instance deLitteralsituée dans le tas et représentant le littéralx2. - Afficher les littéraux désignés par
wetu. - Utiliser la méthode
egalpour comparer les deux littéraux, et afficher le résultat de la comparaison.
Litteral w(0, "x1");
Litteral* u = new Litteral(1,"x2");
w.affiche();
u->affiche();
cout << endl << w.egal(*u) << endl;
Donnez les lignes de code, faisant suite aux précédentes, permettant d’échanger les littéraux désignés par w et u.
Litteral tmp = w;
w = *u;
*u = tmp;
Exercice d’entrainement G.ent2.2
On appelle clause un ensemble de littéraux. Une clause peut être vide ou contenir un littéral ou plusieurs littéraux. La classe suivante permet de représenter une clause.
class Clause
{
private:
vector<Litteral> data;
public:
Clause();
Clause(Litteral& w);
Clause(Litteral& w1, Litteral& w2);
int size();
Litteral& getLit(int i);
void affiche();
bool contient(Litteral& w);
void addLit(Litteral& w);
void addLit(bool signe, const string& nom);
bool egal(Clause& autre);
};
Le constructeur par défaut crée une clause vide. Les deux autres constructeurs créent des clauses contenant les littéraux désignés par leurs paramètres.
La méthode size retourne le nombre de littéraux de la clause courante et la méthode getLit retourne le littéral situé en position i dans cette clause (c’est à dire dans le le vecteur désigné par l’attribut data).
La méthode contient retourne true si et seulement si le littéral désigné par w appartient à la clause courante.
Les deux méthodes addLit permettent d’ajouter un nouveau littéral à la clause courante, mais seulement si ni ce littéral, ni son opposé ne sont déjà dans la clause courante.
La méthode egal détermine si la clause courante est identique à celle désignée par autre, c’est à dire si ces deux clauses comportent exactement les mêmes littéraux, même s’ils apparaissent dans des ordres différents.
Donnez les définitions des trois constructeurs.
Clause::Clause()
{
}
Clause::Clause(Litteral& w)
{
data.push_back(w);
}
Clause::Clause(Litteral& w1, Litteral& w2)
{
data.push_back(w1);
data.push_back(w2);
}
L’attribut data est initialisé implicitement par le constructeur par défaut de la classe vector.
Donnez les définitions des méthodes size et getLit.
int Clause::size()
{
return (int)data.size();
}
Litteral& Clause::getLit(int i)
{
return data[i];
}
Donnez la définition de la méthode affiche. L’affichage d’une clause vide doit se faire sous la forme (). Pour une clause non vide, la forme doit être (+x1,-x2).
void Clause::affiche()
{
int n = (int)data.size();
cout << "(";
if(n>0)
{
getLit(0).affiche();
}
for(int i=1; i<n; i++)
{
cout << ",";
getLit(i).affiche();
}
cout << ")" << endl;
}
On aurait pu écrire data[0] à la place de getLit(0), mais l’usage d’une méthode d’accès facilite une éventuelle modification ultérieure de la représentation d’une clause.
Donnez la définition de la méthode contient.
bool Clause::contient(Litteral &w)
{
int n = (int)data.size();
for(int i=0; i<n; i++)
{
if (getLit(i).egal(w)) return true;
}
return false;
}
Donnez les définitions des deux méthodes add.
void Clause::addLit(Litteral &w)
{
Litteral negw(!w.getSigne(),w.getId());
if(!contient(w) && !contient(negw))
{
data.push_back(w);
}
}
void Clause::addLit(bool signe, const string& nom)
{
Litteral w(signe, nom);
addLit(w);
}
De nombreuses variantes sont possibles, y compris une qui utiliserait une méthode neg qui serait ajoutée à la classe Litteral et produirait l’opposé du littéral courant. Il est important d’éviter la duplication du code permettant de vérifier si le littéral à ajouter ou son opposé se trouve déjà dans la clause. C’est pour éviter une telle duplication de code que la forme à deux paramètres appelle l’autre forme de la méthode.
Donnez la définition de la méthode egal.
On considère que chacune des deux clauses à comparer ne comporte ni plusieurs occurrences d’un même littéral, ni un littéral et son opposé (ce qui est vérifié lors de l’ajout d’un littéral avec les méthodes addLit).
bool Clause::egal(Clause& autre)
{
int n = size();
if(n != autre.size()) return false;
for(int i=0; i<n; i++)
{
if(!contient(autre.getLit(i)))
{
return false;
}
}
return true;
}
On s’assure que les deux clauses ont le même nombre de littéraux. Si ne n’est pas le cas, on peut immédiatement conclure qu’elles ne sont pas égales. Si c’est le cas, il suffit de vérifier que chaque littéral d’une des clauses est présent dans l’autre.
Donnez les lignes de code permettant de réaliser les actions suivantes :
- Créer dans deux variables, nommées
wetu, les littéraux+x1et-x2. - Créer dans une variable
q1la clause contenant les littéraux désignés parwetu. - Créer dans une variable
q2une copie de la clause désignée parq1. - Tenter d’ajouter le littéral
+x2à la clause désignée parq1. (La clause ne devrait pas être modifiée car elle contient déjà l’opposé du littéral.) - Vérifier l’égalité des deux clauses avec la méthode
egalet afficher le résultat (qui devrait être 1). - Ajouter le littéral
-x3à la clause désignée parq2. - Vérifier l’égalité des deux clauses avec la méthode
egalet afficher le résultat (qui devrait être 0). - Afficher les deux clauses.
Litteral w(1, "x1");
Litteral u(0, "x2");
Clause q1(w, u);
Clause q2(q1);
q1.addLit(1,"x2");
cout << q1.egal(q2) << endl;
q2.addLit(0,"x3");
cout << q1.egal(q2) << endl;
q1.affiche();
q2.affiche();