Intro Classes

Les classes
1 Définition
Les classes C++ permettent d’implanter la notion de paquetage introduite [§ 1.3.2]. Une classe C++
peut se rapprocher de la notion de module définie en C, et se trouve implantée dans deux fichiers : l’interface
et l’implantation. On trouve à l’intérieur d’une classe C++ des attributs, correspondants aux variables
définies dans la classe, et des méthodes correspondant aux services offerts par la classe [PROG. 3.1, 3.2].
1 #ifndef __ARTICLE_H_INCLUDED__
2 #define __ARTICLE_H_INCLUDED__
34
class Article {
5 public:
6 // Nom de l’article
7 const char* nom();
89
// Prix brut de l’article
10 float prixBrut();
11
12 // Quantité en stock
13 int quantite();
14
15 // Ajout d’articles dans le stock
16 void ajout(int quantite);
17
18 // Suppression d’articles dans le stock
19 void suppression(int quantite);
20
21 protected:
22 char* _nom; // Nom de l’article
23 float _prixBrut; // Prix brut de l’article
24 int _quantite; // Quantité en stock
25 };
26
27 #endif /* __ARTICLE_H_INCLUDED__ */
PROG. 3.1 – Interface de la classe Article (Article.H).
Pour déclarer une classe C++, il faut utiliser le mot-clé class. Les différents attributs et méthodes
sont ensuite énumérés de la même manière que des champs sont définis à l’intérieur d’une structure C.

1 #include "Article.H"
23
// **********************************************************************
45
const char*
6 Article::nom()
7 {
8 return _nom;
9 }
10
11 // **********************************************************************
12
13 float
14 Article::prixBrut()
15 {
16 return _prixBrut;
17 }
18
19 // **********************************************************************
20
21 int
22 Article::quantite()
23 {
24 return _quantite;
25 }
26
27 // **********************************************************************
28
29 void
30 Article::ajout(int quantite)
31 {
32 _quantite += quantite;
33 }
34
35 // **********************************************************************
36
37 void
38 Article::suppression(int quantite)
39 {
40 _quantite -= quantite;
41 }
PROG. 3.2 – Implantation de la classe Article (Article.C).
22
2. Utilisation
a cependant quelques différences :
– Les structures C ne permettent que de regrouper des variables, alors que les classes C++ permettent
également de regrouper des fonctions (les méthodes). Ces fonctions sont également appelées fonctions
membres pour les différencier des fonctions qui sont définies en dehors de toute classe.
– Une classe C++ peut comporter plusieurs sections, chacune d’elles étiquetée par l’un des mots-clés
suivants : public, protected, private. Ces mots-clés permettent de définir le niveau de
masquage de l’information tel qu’il a été défini [§ 1.2.3] :
– une section public permet de déclarer les attributs ou les méthodes qui sont accessibles par n’importe quel client de la classe, c’est-à-dire à n’importe quel autre endroit du programme,
que ce soit à l’intérieur de cette classe, d’une autre classe, ou en dehors du contexte de toute classe ;
– une section protected ou private permet de déclarer les attributs et méthodes qui sont
inaccessibles aux clients extérieurs à la classe, mais pas à la classe elle-même. Toute tentative
d’accès à ces informations par un client extérieur se soldera alors par une erreur de compilation.
La distinction qui existe entre les sections protected et private ne concerne pas les
clients d’une classe, mais est relative à l’héritage ; elle est expliquée [§ 4.2].
Remarque : afin de bien différencier les identificateurs (attributs, méthodes) publics de ceux qui ne
le sont pas, on utilise généralement une convention d’écriture, qui correspond ici au préfixe ’_’
utilisé.
– Dans ce contexte, les attributs de classe sont conventionnellement protégés, en les déclarant dans
une section autre que public. La conséquence de ce masquage de l’information est que les attributs
d’une classe ne sont plus directement accessibles. On définit alors des méthodes permettant
d’accéder à leur valeur. Ces méthodes sont désignées sous l’appellation fonctions d’accès. C’est ce
qu’on appelle de l’encapsulation : la structure de données réelle est masquée et peut donc évoluer.
Du coup, on ne montre que ce que l’on veut, et sous la forme que l’on veut.
La définition des méthodes d’une classe se fait dans le fichier d’implantation de la classe. Le prototype 4 des méthodes est repris et est préfixé par le nom
de la classe à laquelle appartiennent les méthodes et par l’opérateur de résolution de portée ’::’.