Université Hassan 1er

Faculté des Sciences et Techniques

-Settat-

Filière : Master en Réseaux et Systèmes Informatiques

Module : Programmation orientée objet avancée

Chapitre 2 : Classes, objets, attributs et méthodes en

C++

Prof. Said El Kafhali

Département Mathématiques & Informatique

Faculté des Sciences et Techniques, Settat
Université Hassan 1er

Année Universitaire : 2024/2025

Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
1 / 63 en C++
Plan

1 Classes et objets

2 Propriétés des atributs et fonctions membres

3 Relation entre classes

4 Références

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
2 / 63 en C++
 Classes et objets

Définition d’une classe en C++

Une classe décrit le modèle structurel d’un objet :
Ensemble des attributs (ou champs ou données membres) décrivant sa
structure.
Ensemble des opérations (ou méthodes ou fonctions membres) qui lui
sont applicables.
Une classe en C++ est une structure définit par le mot clé class suivit
du nom de la classe et des données.
Exemple
1 class Rectangle {
2 private: // membres privées
3 double hauteur;
4 double largeur;
5 public: // membres publiques
6 double Surface();
7 }; // La déclaration de la classe Rectangle se fait
dans un fichier d’en-tête (header) Rectangle.h.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
3 / 63 en C++
 Classes et objets

Encapsulation et droits d’accès (1/3)

L’encapsulation consiste à masquer l’accès à certains attributs et
méthodes d’une classe.
Elle est réalisée à l’aide des mots clés :
Accès private : les membres privés ne sont accessibles que par les
fonctions membres de la classe. La partie privée est aussi appelée
réalisation. Il est invisible de l’extérieur de la classe.
Accès protected : les membres protégés sont comme les membres
privés. Mais ils sont aussi accessibles par les fonctions membres des
classes dérivées.
Accès public : les membres publics sont accessibles par tous. La partie
publique est appelée interface.
Les mots réservés private, protected et public peuvent figurer plusieurs
fois dans la déclaration de la classe.
Remarque
Le droit d’accès ne change pas tant qu’un nouveau droit n’est pas spécifié.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
4 / 63 en C++
 Classes et objets

Encapsulation et droits d’accès (2/3)

Règle POO
Les attributs doivent être encapsulées dans la classe pour éviter une
utilisation extérieure.
C’est une forme de protection permettant d’éviter une utilisation
incorrecte ou non prévue par le programmeur de la classe.
On appliquera ce principe en déclarant l’ensemble des attributs en
private.
Si c’est nécessaire, l’accès aux attributs privés d’une classe se fera par
l’intermédiaire de méthodes nommées des accesseurs et manipulateurs.
On a l’habitude de les nommer get() pour l’accès en lecture et set()
pour l’accès en écriture d’un attribut.

Les droits d’accès aux membres d’une classe concernent aussi bien les
méthodes que les attributs.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
5 / 63 en C++
 Classes et objets

Encapsulation et droits d’accès (3/3)

Exemple
1 class Rectangle {
2 private:
3 double hauteur; // je suis un attribut privé de type
double
4 double Surface(); // je suis une méthode privée de nom
Surface
5 public: // seulement des méthodes ici (regle POO)
6 double getHauteur(); // je suis l’accesseur get de
hauteur, je retourne sa valeur
7 void setHauteur(double); // je suis le manipulateur set
de hauteur, je fixe sa valeur
8 void afficher(); // je suis une autre méthode publique
9 };

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
6 / 63 en C++
 Classes et objets

Opérateur de réssolution de portée : :

Lorsque les définitions des classes deviennent complexes, la lisibilité du
code diminue, car on perd la vue d’ensemble des comportements
définit dans une classe.
Il est toutefois possible de retrouver cette vue d’ensemble, en écrivant
les définition des méthodes à l’extérieur de la déclaration de la classe.
Ceci est rendu possible grâce à l’opérateur de résolution de portée
« : :», qui permet de relier la définition d’une méthode à la classe
pour laquelle elle est définie.
Grace à cet opérateur, le programmeur peut se contenter d’indiquer
les prototypes des méthodes dans la déclaration de la classe, et écrire
les définitions correspondantes, à l’extérieur de la déclaration, sous la
forme de définition de fonctions de nom

1 <nom de classe>::<nom de fonction>(<arg1>,<arg2>, ...)

2 { ... }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
7 / 63 en C++
 Classes et objets

Définition des méthodes d’une classe en C++

La définition d’une classe revient à définir l’ensemble de ses méthodes.
Les méthodes sont des membres de la classe. Il s’agit de fonctions qui
permette d’agir sur les objets de la classe.
En général les entêtes sont définis dans la classe et le corps des
méthodes en dehors.
On doit faire précéder chaque méthode de l’opérateur de résolution de
portée : : précédé du nom de la classe pour préciser au compilateur
que ce sont des membres de cette classe.
La définition des méthodes de la classe Rectangle se fait dans un
fichier source Rectangle.cpp.
Exemple
1 #include "Rectangle.h"
2 double Rectangle::Surface(){
3 return hauteur*largeur;
4}
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
8 / 63 en C++
 Classes et objets

Actions et prédicats

En C++, on peut distinguer les méthodes qui modifient l’état de

l’objet (actions) de celles qui ne changent rien à l’objet (prédicats).
On peut pour cela ajouter le mot const après la liste des paramètres
de la méthode.

Exemple
1 #include "Rectangle.h"
2 double Rectangle::Surface() const{
3 return hauteur*largeur;
4}

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
9 / 63 en C++
 Classes et objets

Instances de classe en C++

Instancier un objet revient à créer une variable d’un type classe. Une
instance de classe est donc un objet.
Le mot-clé this (auto pointeur), utilisé dans le code des méthodes
d’une classe, fait référence à l’instance ( l’objet lui-même) sur laquelle
est invoquée la méthode.
La déclaration d’une instance d’une classe se fait de la même façon
que la déclaration d’une variable.

Exemple
1 Rectangle rect; // Déclare une instance rect de la
classe Rectangle.
2 Rectangle * rect1;

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
10 / 63 en C++
 Classes et objets

Accès aux attributs

L’accès aux attributs se fait avec l’opérateur d’accès . ou l’opérateur

d’indirection -> si on manipule une adresse comme pour accèder aux
champs d’une structure.

Exemple
1 rect.hauteur; // Accès àla valeur de l’attribut hauteur
d’une instance rect de la classe Rectangle.
2 rect->hauteur; // Si on manipule une adresse

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
11 / 63 en C++
 Classes et objets

Initialisation des attributs

Affecter individuellement une valeur à chaque attribut.
1 Rectangle rect;
2 double h,l;
3 Cout <<"Quelle hauteur"; cin >> h;
4 rect.setHauteur(h);
5 Cout <<"Quelle largeur"; cin >> l;
6 rect.setLargeur(l);

Définir une méthode dédiée à l’initialisation des attributs.

1 class Rectangle{
2 private:
3 double hauteur, largeur;
4 public:
5 void init(double h, double l){
6 hauteur=h; largeur=l; }
7 };
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
12 / 63 en C++
 Classes et objets

Constructeur (1/2)
L’instanciation d’un objet est réalisée par l’appel à un constructeur
(une méthode qui porte le même nom que la classe).
Un constructeur est une méthode invoquée automatiquement lors de
la déclaration d’un objet, chargée d’effectuer toutes les opérations
requises en début de vie de l’objet dont l’initialisation des attributs.
Les constructeurs sont des méthodes presque comme les autres. Il
existe quelques contraintes :
Il peut avoir des paramètres, et des valeurs par défaut.
Il peut y avoir plusieurs constructeurs pour une même classe (peuvent
être surchargés).
Il n’a jamais de type de retour (pas même void).
Il existe implicitement un constructeur par défaut :
Son rôle est de créer une instance non initialisée quand aucun autre
constructeur fourni n’est applicable.
Il est sans paramètre.
Il est fortement recommandé d’écrire soi-même le constructeur par
défaut. Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
13 / 63 en C++
 Classes et objets

Constructeur (2/2)
Un constructeur est chargé d’initialiser un objet de la classe.
Il est appelé automatiquement au moment de la création de l’objet.
Un constructeur est une méthode qui porte toujours le même nom que
la classe.
Exemple
1 class Rectangle{
2 private:
3 double hauteur;
4 double largeur;
5 public:
6 Rectangle(double, double); // Déclaration du constructeur
7 };
8 Rectangle::Rectangle(double h, double l){ // Définition du
constructeur
9 hauteur=h;
10 largeur=l; }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
14 / 63 en C++
 Classes et objets

Liste d’initialisation et constructeur

Un meilleur moyen d’affecter des valeurs aux données membres de la
classe lors de la construction est la liste d’initialisation.
On rajoute un symbole deux-points ( :) suivi de la liste des attributs
que l’on veut initialiser avec, entre parenthèses, la valeur.
Reprenons le constructeur que nous venons de créer :
1 Rectangle::Rectangle(double h, double l){
2 hauteur=h; largeur=l; }

Le code que vous allez voir ci-dessous produit le même effet :

1 Rectangle::Rectangle(double h, double l) : hauteur(h),
largeur(l){
2 //Rien àmettre dans le corps du constructeur, tout a
déjà été fait !
3 // autres opérations
4}
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
15 / 63 en C++
 Classes et objets

Constructeur par défaut

Un constructeur par défaut est un constructeur qui ne prend aucun
argument. Il n’a pas de paramètres.
Généralement, il est utilisé pour donner des valeurs par défaut aux
données membres.

1 class Rectangle{
2 private:
3 double hauteur;
4 double largeur;
5 public:
6 Rectangle(); // Déclaration du constructeur par défaut
7 };
8 Rectangle::Rectangle(){ // Définition du constructeur par
défaut
9 hauteur = 10;
10 largeur = 5;}
11 Rectangle rect;// appel du constructeur par défaut :
initialise hauteur à10 et largeur à5
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
16 / 63 en C++
 Classes et objets

Initialisation des attributs

Le corps du constructeur est précédé d’une section optionnelle
introduite par « :», spécifiquement réservée à l’initialisation des
attributs.
Les attributs non initialisés dans cette section prendront une valeur par
défaut dans le cas où une telle valeur existe ou resterons non initialisés
dans le cas contraire.
Il est bien sûr possible de changer la valeur d’un attribut initialisé ou
d’affecter une valeur à un attribut non initialisé dans le corps du
constructeur.
Exemple
1 Rectangle(const double h, const double l) : hauteur(h) //
initialisation de hauteur
2 {// largeur àune valeur indéfinie
3 double t(2*l - h % 2);
4 largeur = t; // affectation
5} Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
17 / 63 en C++
 Classes et objets

Argument à valeur par défaut

Comme les autres méthodes et fonctions en général, les constructeurs

peuvent admettre des arguments pour lesquels une valeur par défaut
est spécifiée.
1 Rectangle(const double h, const double l = 10)
2 : hauteur(h), largeur(l)
3{ }

Dans ce cas, la déclaration d’une instance rect de la forme :

1 Rectangle rect(5);

est alors équivalente à la déclaration :

1 Rectangle rect(5,10);

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
18 / 63 en C++
 Classes et objets

Surcharger les constructeurs

Comme dans le cas des autres méthodes, il est tout à fait possible de
surcharger les constructeurs ; une classe peut donc admettre plusieurs
constructeurs, pour autant que leurs listes d’arguments soient
différentes.
Exemple
1 class Rectangle {
2 private:
3 double hauteur, largeur;
4 public:
5 Rectangle(const double c) : hauteur(c), largeur(c) { }
6 Rectangle(const double h, const double l) : hauteur(h),
largeur(l) { }
7 // autres méthodes ........
8 unsigned int surface() {...}
9 void changeHauteur(...) {...}
10 };
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
19 / 63 en C++
 Classes et objets

Destructeur (1/2)

Un destructeur est une méthode membre de la classe qui est appelée

implicitement à la destruction de l’objet.
qui porte comme nom, le nom de la classe précédé du caractère (tilda).
qui ne retourne pas de valeur (pas même un void ).
qui n’accepte aucun paramètre (le destructeur ne peut donc pas être
surchargé).
Son rôle est de libérer toutes les ressources qui ont été acquises depuis
la construction (typiquement libérer la mémoire qui a été allouée
dynamiquement par cet objet).
Le compilateur générera un destructeur par défaut si le concepteur de
la classe n’en spécifie pas un.
Si des constructeurs sont définis avec des paramètres, le compilateur ne
générera pas le constructeur par défaut.
Les constructeurs et destructeurs sont les seules méthodes non
constantes qui peuvent être appelées pour des objets constants.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
20 / 63 en C++
 Classes et objets

Destructeur (2/2)

1 class Rectangle{
2 public:
3 ~Rectangle(); // Destructeur
4 };
5 Rectangle::~Rectangle(){ // Destructeur
6}
7 // Exemple :
8 Rectangle* rect;
9 rect = new Rectangle(10, 5);
10 delete rect; // appel automatique du destructeur

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
21 / 63 en C++
 Classes et objets

Constructeur par recopie (copy constructor) (1/3)

Constructeur créé par défaut mais pouvant être redéfini.

Appelé lors de l’initialisation d’un objet par recopie d’un autre objet,
lors du passage par valeur d’un objet en argument de fonction ou en
retour d’un objet comme retour de fonction.
1 MaClasse c1;
2 MaClasse c2=c1; // Appel du constructeur par recopie

Possibilité de définir explicitement un constructeur par copie si

nécessaire :
Un seul argument de type de la classe.
Transmission de l’argument par référence.

1 MaClasse(MaClasse &);
2 MaClasse(const MaClasse &) ;

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
22 / 63 en C++
 Classes et objets

Constructeur par recopie (copy constructor) (2/3)

Exemple
1 class Exemple
2{
3 public :
4 int attribut;
5 Exemple(int); // Déclaration du constructeur
6 ~Exemple(); // Déclaration du destructeur
7} ;
8 int main()
9{
10 Exemple e(1); // Déclaration d’un objet Exemple
11 Exemple e1=e; // Initialisation d’un objet par recopie
12 return 0;
13 }

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
23 / 63 en C++
 Classes et objets

Constructeur par recopie (copy constructor) (3/3)

Exemple : définition explicite du constructeur par recopie
1 class Exemple
2 { public :
3 int attribut;
4 Exemple(int);
5 // Déclaration du constructeur par recopie
6 Exemple(const Exemple &);
7 ~Exemple();
8} ;
9 // Définition du constructeur par recopie
10 Exemple::Exemple (const Exemple & e)
11 { cout << "** Appel du constructeur par recopie ";
12 attribut = e.attribut; // Recopie champ àchamp
13 cout << " - valeur de l’attribut après recopie = " <<
attribut << endl;
14 }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
24 / 63 en C++
 Classes et objets

Régles d’utilisation des fichiers .cpp et .h

Pour pouvoir effectivement réutiliser les classes programmées et les

compiler séparément, il est indispensable de les exploiter proprement
et les ranger dans des fichiers qui portent des noms corrects.
La déclaration d’une classe Classe doit être mise dans un fichier
classe.h.
La définition d’une classe Classe doit être mise dans un fichier
classe.cpp.
On peut dire que :
Le fichier .cpp est le corps de la classe.
Le fichier .h est l’interface de la classe.
Ces structures de fichiers permettent la réutilisation et la compilation
séparée.

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
25 / 63 en C++
 Classes et objets

Structure d’un fichier classe.h

Un fichier classe.h possède la structure suivante :

1 #ifndef CLASSE_H
2 #define CLASSE_H
3 #include ... // includes de classes eventuelles
4 ...
5 class Classe {
6 ...
7} ;
8 #endif

#ifndef, #define et #endif servent de garde-fou pour que le fichier ne

soit effectivement inclus qu’une seule fois lors d’une compilation.

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
26 / 63 en C++
 Classes et objets

Personne.h

1 class Personne{
2 public: // membres publics
3 Personne();// constructeur par défaut
4 Personne(char nom[], char adresse[]); // constructeur
5 void afficher(); // affiche les attributs de la personne
6 void setAdresse(char adresse[]); // accesseur (setter)
7 int egal(char nom[]); // Retourne 1 si le nom de la
personne est égal au paramètre, 0 sinon
8 private: // membres privés de la classe
9 char nom[30];
10 char adresse[50];
11 void verifLongChaine(char ch[], int lg); // méthode privée
utilisée pour tester la cohérence des paramètres des
méthodes public déclarées ci-dessus si (strlen(ch) >
lg) affiche un message et arrête le programme
12 }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
27 / 63 en C++
 Classes et objets

Structure d’un fichier classe.cpp

Un fichier classe.cpp possède la structure suivante :

1 #include "classe.h" // include de sa propre classe
2 #include ... // autres includes optionnels
3 ...
4 Classe ::Classe(...) { // définition du constructeur
5 ...
6}
7 Classe ::~Classe() { // définition du destructeur
8 ...
9 }.
10 .. // autres définitions de fonctions membres
11 #endif

Noter l’include obligatoire de classe.h dans le fichier classe.cpp ; les

autres sont optionnels.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
28 / 63 en C++
 Classes et objets

Personne.cpp

1 #include "Personne.h"
2 #include <iostream>
3 #include <string.h>
4 #include <stdlib.h>
5 using namespace std;
6 Personne::Personne() // préfixe Personne::
7{
8 nom[0] = adresse[0] = ’\0’; // chaînes vides
9}
10 Personne::Personne(char nom[], char adresse[])
11 {
12 verifLongChaine(nom, 29);
13 verifLongChaine(adresse, 49);
14 strcpy(this->nom, nom); // this pour l’instance courante
15 strcpy(this->adresse, adresse);
16 }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
29 / 63 en C++
 Classes et objets

Personne.cpp (suite)

1 void Personne::setAdresse(char adresse[]){

2 verifLongChaine(adresse, 49);
3 strcpy(this->adresse, adresse);
4}
5 int Personne::egal(char nom[]){
6 return strcmp(this->nom, nom) == 0;
7}
8 void Personne::verifLongChaine(char ch[], int lg){
9 if (strlen(ch) > lg) {
10 cout << "chaîne trop longue" << ch << endl;
11 exit(0);}
12 }
13 void Personne::afficher(){
14 cout << "Nom : " << nom << " - Adresse : " << adresse <<
endl ;
15 }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
30 / 63 en C++
 Classes et objets

Structure d’un programme en C++

Pour chaque classe : un fichier .h contenant sa déclaration et un
fichier .cpp contenant sa définition.
Un fichier .cpp contenant le traitement principal.

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
31 / 63 en C++
 Classes et objets

Programme utilisant la classe Personne

1 #include "Personne.h"
2 #define NMAX_PERSONNES 100
3 void afficher(Personne tab[], int nb_elem){
4 for (int i=0; i<nbElem; i++) tab[i].afficher(); }
5 void ajouter( Personne p, // Une personne
6 Personne tab[], // adresse d’un tableau
7 short & nbElem) // Nbre d’éléments du tableau
8 { if ( nbElem != NMAX_PERSONNES ) tab[nbElem++]=p;
9}
10 int main(){
11 Personne tab[100]; // tableau de Personne
12 short nbElem=0;
13 ajouter(Personne("xxxx", "yyyy"), tab, nbElem);
14 ajouter(Personne("yyyyy", "zzzzz"), tab, nbElem);
15 afficher(tab, nbElem);
16 return 0; }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
32 / 63 en C++
 Classes et objets

Espaces de noms (1/2)

Utilisation d’espaces de noms (namespace) lors de l’utilisation de
nombreuses bibliothèques pour éviter les conflits de noms.
Un espace de noms contient du code et le code contenu n’est visible
que dans cet espace.
L’instruction namespace permet d’écrire ses propres espaces de noms.
1 namespace monespace{ // le nom de l’espace de noms
2 // ici les déclarations et les définitions de
variables, fonctions, classes, objets...
3}

Exemple
1 namespace monespace{
2 int MaFonction(int n) {
3 return n+1; } }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
33 / 63 en C++
 Classes et objets

Espaces de noms (2/2)

Si la fonction MaFonction() est définie dans l’espace de noms

monespace, l’appel de la fonction se fait par :
1 int a = monespace::MaFonction(5);

Pour éviter l’appel explicite à un espace de noms en utilisant le mot

clé using.
1 using monespace::MaFonction;
2 ...
3 int a = MaFonction(5);
4 // ou encore utiliser la directive using
5 using namespace monespace;
6 ...
7 int a = MaFonction(5);

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
34 / 63 en C++
 Classes et objets

Exemple

1 #include <iostream>
2 using namespace std ;
3 // déclaration d’une constante dans un espace de nom
4 namespace MonEspace{const int max=10;}
5 class MaClasse {
6 int tableau[MonEspace::max]; // utilisation de la
constante max
7 public:
8 MaClasse() { cout << "constructeur" << endl ;
9 for(int i=0; i< MonEspace::max; i++) tableau[i]=i; }
10 void afficher() { for(int i=0; i< MonEspace::max; i++)
11 cout << "tableau[" << i << "]=" << tableau[i] << endl; }
12 };
13 int main() {
14 cout << "constante : " << MonEspace:: max << endl;
15 MaClasse c; c.afficher();}
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
35 / 63 en C++
 Classes et objets

Tableaux d’objets
Il est possible de conserver et de manipuler des objets Personne dans
un tableau.
Dans une approche objet, on écrirait plutôt une classe
TableauDePersonnes dont chaque instance représente un tableau de
personnes.
1 #include "Personne.h"
2 class TableauDePersonnes {
3 private:
4 const int NMAX_PERSONNES = 100;
5 Personne tab[NMAX_PERSONNES];
6 int nbElem;
7 public:
8 TableauDePersonnes();// constructeur par défaut
9 void ajouter(Personne p);
10 void afficher();
11 };
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
36 / 63 en C++
 Classes et objets

TableauDePersonnes.cpp

1 #include "TableauDePersonnes.h"
2 TableauDePersonnes::TableauDePersonnes()
3{
4 nbElem = 0;
5}
6 void TableauDePersonnes ::ajouter(Personne p)
7{
8 if ( (nbElem) < NMAX_PERSONNES )
9 tab[nbElem++] = p;
10 }
11 void TableauDePersonnes ::afficher()
12 {
13 for (int i=0; i<nbElem; i++) tab[i].afficher();
14 }

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
37 / 63 en C++
 Classes et objets

Utilisation

1 #include "TableauDePersonnes.h"
2 int main()
3{
4 TableauDePersonnes tabPers;
5 tabPers.ajouter(Personne("xxxxx", "yyyyy"));
6 tabPers.ajouter(Personne("yyyyywww","zzzzzz"));
7 tabPers.afficher();
8 return 0 ;
9}

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
38 / 63 en C++
 Classes et objets

Les objets automatiques

Les objets automatiques sont les objets déclarés dans une fonction ou
dans un bloc.
1 void f() {
2 Personne p1 ; // p1 est construit ici
3 ... {
4 Personne p2 ; // p2 est construit ici
5 ...
6 } // p2 est détruit ici
7 } // p1 est détruit ici

p1 et p2 sont des objets automatiques. p1 est visible dans la fonction f

et p2 est dans le bloc.
A la sortie de la fonction p1 est détruit. A la sortie du bloc, p2 est
détruit.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
39 / 63 en C++
 Classes et objets

Les objets constants

On déclare un objet constant avec le modificateur const.

Une variable déclarée const doit être initialisée lors de sa déclaration.
On ne pourra pas modifier l’état (ses attributs) d’un objet constant.
On ne peut appliquer que des méthodes constantes sur un objet
constant.
Une méthode constante est tout simplement une méthode qui ne
modifie aucun des attributs de l’objet.
Une méthode const peut appelée sur tout type de variable tandis
qu’une méthode non const ne peut être appelée que sur une variable
non constante.
Le const fait partie de la signature de la méthode, il doit être présent
dans le .cpp et le .h.

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
40 / 63 en C++
 Classes et objets

Les objets constants (exemple)

1 class Personne{
2 private:
3 int age;
4 public:
5 float getAge() const;
6 };
7 // Une méthode constante
8 float Personne::getAge() const {
9 return this->age;
10 }
11 const Personne p("xxxxx", "yyyyy"); // p est un objet
constant
12 float x = p.getAge(); // autorisé : getAge() est déclarée
const
13 p.ajouter(); // interdit : ajouter() n’est pas const

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
41 / 63 en C++
 Propriétés des atributs et fonctions membres

Les membres statiques

Les membre statiques sont souvent utilisés pour compter le nombre

d’instances créées.

Les attributs statiques

Un membre donnée déclaré avec l’attribut static est partagé par tous
les objets de la même classe. C’est un attribut de classe et non d’objet.
Il existe même lorsque aucun objet de cette classe n’a été créé.
Un membre donnée statique doit être initialisé explicitement, à
l’extérieur de la classe (même s’il est privé), en utilisant l’opérateur de
résolution de portée ( : :) pour spécifier sa classe.
Il y a une exception pour un membre statique constant. Dans ce cas,
l’initialisation se fait dans la classe elle-même.
En général, son initialisation se fait dans le fichier .cpp de définition de
la classe.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
42 / 63 en C++
 Propriétés des atributs et fonctions membres

Les membres statiques

Les méthodes statiques

Lorsqu’une fonction membre a une action indépendante d’un
quelconque objet de sa classe, on peut la déclarer avec l’attribut static.
Dans ce cas, une telle fonction peut être appelée, sans mentionner
d’objet particulier, en préfixant simplement son nom du nom de la
classe concernée, suivi de l’opérateur de résolution de portée ( : :).
Les méthodes statiques ne peuvent pas accéder aux attributs de la
classe car il est possible qu’aucun objet de cette classe n’ait été créé.
Les méthodes statiques peuvent accéder aux membres données
statiques car ceux-ci existent même lorsque aucun objet de cette classe
n’a été créé.

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
43 / 63 en C++
 Propriétés des atributs et fonctions membres

Déclaration des membres statiques

Les membres statiques sont déclarées, comme les autres, dans la

déclaration de la classe.
Leur seule singularité est ici la présence de mot clé static qui indique
leur statut.

1 class Personne {
2 private:
3 ...
4 static int nbPersonnes; // je suis un membre donnée
statique
5 public:
6 ...
7 static int getNbPersonnes(); // je suis une méthode
statique
8 };

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
44 / 63 en C++
 Propriétés des atributs et fonctions membres

Définition des membres statiques

1 // Initialisation d’un membre statique (dans le fichier

.cpp)
2 int Personne::nbPersonnes = 0;
3 Personne::Personne(){ // Constructeur
4 ...
5 nbPersonnes++; // un objet Personne de plus !
6}
7 Personne::~Personne(){ // Destructeur
8
9 nbPersonnes--; // un objet Personne de moins !
10 }
11 // Je retourne le nombre d’objets Personne existants àun
instant donné
12 int Personne::getNbPersonnes(){
13 return nbPersonnes;
14 }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
45 / 63 en C++
 Propriétés des atributs et fonctions membres

Les objets statiques

Un objet statique est un objet déclaré avec le mot-clé static dans une
déclaration de classe ou dans une fonction ou bien à l’extérieur de
toute fonction.
Un objet statique est créé avant le début de l’exécution du programme
et il est détruit à la sortie du programme.

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
46 / 63 en C++
 Propriétés des atributs et fonctions membres

Opérateurs new et delete

new et delete permettent d’allouer/libérer en mémoire dynamique des

variables classiques (scalaires, structures, tableaux) et des objets.

Mémoire dynamique : variables classiques

1 int *i;
2 i = new int; // allocation de la mémoire
3 cout << *i;
4 delete i; // lirération de la mémoire
5 char *chaine;
6 chaine = new char[50]; // allocation de la mémoire
7 strcpy(chaine,"xxxxx yyyyy zzzzz");
8 cout << chaine;
9 delete [] chaine; // lirération de la mémoire

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
47 / 63 en C++
 Propriétés des atributs et fonctions membres

Les objets dynamiques

Un objet dynamique est un objet créé avec new et éventuellement

détruit avec delete.

Exemple
1 Personne * p; // pointeur sur un objet de classe Personne
2 p = new Personne; // allocation
3 p = new Personne("xxxxxxx", "yyyyyyyyy");
4 p->afficher();
5 delete p; // libération
6 x = new Personne[10]; // alloue de la mémoire pour 10
Personnes
7 delete [] x; // libère cette mémoire

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
48 / 63 en C++
 Propriétés des atributs et fonctions membres

Tableau d’objets

1 int main()
2{
3 int i;
4 Personne * tab; // poiteurr sur tableau de personnes
5 tab = new Personne[10]; // tableau de 10 personnes
6 // constructeur par défaut
7 tab[0]=Personne("xxxxxxx", "yyyyyyyyy");
8 tab[1]=Personne("wwwwwww", "zzzzzzzzz");
9 for (i=0; i<2; i++)
10 tab[i].afficher();
11 delete [] tab; // libération du tableau
12 return 0;
13 }

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
49 / 63 en C++
 Propriétés des atributs et fonctions membres

Tableau dynamique d’objets dynamiques

Les éléments du tableau pointent sur des objets eux mêmes situés en
mémoire dynamique.
1 int main() {
2 Personne * * tab; // pointeur sur tableau de pointeurs
3 int nb_elem = 0; // nb de poiteurs présents dans (* tab)
4 tab = new (Personne *) [10]; //tableau de 10 pointeurs
5 tab[nb_elem++] = new Personne("xxxxx", "yyyyyy");
6 tab[nb_elem++] = new Personne("zzzzz", "wwwwww");
7 tab[nb_elem++] = new Personne("gggggg", "rrrrrrrr");
8 for (int i=0; i<nb_elem; i++)
9 tab[i]->afficher(); // tab[i] pointeur
10 for (int i=0; i<nb_elem; i++) // libération des Personnes
11 delete tab[i];
12 delete [] tab; // libération du Tableau
13 return 0;
14 }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
50 / 63 en C++
 Propriétés des atributs et fonctions membres

Classes amies en C++ (1/2)

Une classe amis peut accéder aux membres privés et protégés d’une
autre classe dans laquelle elle est déclarée comme ami.
Il est parfois utile de permettre à une classe particulière d’accéder à
des membres privés d’une autre classe.
Syntaxe
La classe B peut être autorisée à accéder aux membres privés de A.
1 class A {
2 private:
3 int x, y;
4 friend class B; // classe amie de la classe A
5 };

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
51 / 63 en C++
 Propriétés des atributs et fonctions membres

Classes amies en C++ (2/2)

Exemple
1 class A {
2 private: int a;
3 public: A() { a = 10; }
4 friend class B; // Classe ami
5 };
6 class B {
7 private: int b;
8 public:
9 void afficherA(A& f) {
10 cout << "La valeur de a dans la classe A = " << f.a;
} };
11 int main() {
12 A a; B b; b.afficherA(a);
13 return 0;
14 }
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
52 / 63 en C++
 Propriétés des atributs et fonctions membres

Méthode amie en C++ (1/2)

Une méthode amie est une méthode extérieure à la classe ayant accès
aux données privées de la classes.
Plusieurs situations d’amitié :
Une fonction indépendante, amie d’une classe.
Une méthode d’une classe, amie d’une autre classe.
Une fonction amie de plusieurs classes.
Toutes les méthodes d’une classe amies d’une autre classe.

1 class nomClasse{
2 ...
3 friend type_retour nomFonction(liste des paramètres);
4 ...
5 };

Même si les prototypes des fonctions d’amis apparaissent dans la

définition de la classe, les amis ne sont pas des fonctions membres.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
53 / 63 en C++
 Propriétés des atributs et fonctions membres

Méthode amie en C++ (2/2)

Exemple
1 class Rectangle {
2 private:
3 int x, y;
4 friend int Carre::afficher();
5 //Seule afficher() de la classe Carre peut accéder aux
membres internes
6 };

Année Universitaire : 2024/2025

Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
54 / 63 en C++
 Relation entre classes

Association (1/2)
Une association représente une relation durable entre deux classes.
En C++, l’association s’implémente par un pointeur. Les accesseurs
get/set permettent de mettre en oeuvre la relation.

Exemple

La relation possède est une association entre les classes Personne et

Voiture.
Les associations peuvent donc être nommées pour donner un sens
précis à la relation.
La relation possède est bidirectionnelle, on a une navigabilité dans les
deux sens. Ici, Personne possède Voiture et Voiture est possédée par
Personne.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
55 / 63 en C++
 Relation entre classes

Association (2/2)

1 // ------------Classe Personne -------

2 class Personne {
3 private:
4 Voiture *maVoiture; // association vers Voiture
5 public:
6 Voiture* getVoiture();
7 void setVoiture(Voiture* v);
8 };
9 //---------Classe Voiture------------------
10 class Voiture {
11 private:
12 Personne *leProprietaire; // association vers Personne
13 public:
14 Personne* getPersonne();
15 void setPersonne(Personne* p);
16 };
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
56 / 63 en C++
 Relation entre classes

Les multiplicités plusieurs (*)

Pour pouvoir conserver plusieurs instances (c’est-à-dire plusieurs
objets), on doit utiliser un conteneur de type vector, list ou map par
exemple.

1 class Client{
2 private:
3 list<Commande*> mesCommandes; // multiplicité *
4 ...
5 };
6 class Commande{
7 private:
8 Client *leClient; // multiplicité 1
9 ...
10 };
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
57 / 63 en C++
 Relation entre classes

Agrégation (1/2)
L’agrégation est un cas particulier d’association non symétrique
exprimant une relation de contenance.
En C++, l’agrégation s’implémente par un pointeur (ou par référence).

Exemple

Une ligne d’une commande contient l’achat d’un article. Ici, Ligne est
le composite et Article le composant.
Le composant peut être partagé entre plusieurs composites ce qui
entraîne que, lorsque le composite Ligne sera détruit, le composant
Article ne le sera pas forcément.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
58 / 63 en C++
 Relation entre classes

Agregation (2/2)

1 class Ligne{ // Classe Ligne

2 private:
3 Article *article;
4 long quantite;
5 public:
6 Article* getArticle();
7 void setArticle(Article* a);
8 // Ligne(Article* article, long quantite); L’adresse de
l’objet Article peut aussi être un argument passé àun
constructeur de Ligne
9 };
10 class Article{ // Classe Article
11 private:
12 string libelle;
13 double prix;
14 public:
15 ...};
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
59 / 63 en C++
 Relation entre classes

Composition
Une composition est une agrégation plus forte signifiant est composé
d’un et impliquant :
un composant ne peut appartenir qu’à un seul composite (agrégation
non partagée).
la destruction du composite entraîne la destruction de tous ses
composants (il est responsable du cycle de vie de ses parties).

Exemple

La relation de composition ici correspond à la situation :

quand on devra supprimer une commande, on détruira chaque ligne de
celle-ci.
D’autre part, une ligne d’une commande ne peut être partagée avec
une autre commande : elle lui est propre.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
60 / 63 en C++
 Relation entre classes

Composition : implémentation par valeur

1 class Commande {
2 private:
3 Ligne ligne; // multiplicité 1, pour pouvoir conserver
plusieurs lignes (*), on pourrait utiliser un vector de
Ligne : vector<Ligne> lignes;
4 // L’objet Ligne doit être initialisé dans la liste
d’initialisation du constructeur Commande.
5 string date;
6 string reference;
7 ...};
8 class Ligne {
9 private:
10 Article *article;
11 long quantite;
12 public:
13 ...};
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
61 / 63 en C++
 Relation entre classes

Composition : implémentation par pointeur

1 class Commande
2{
3 private:
4 Ligne *ligne; // composition par pointeur
5 public:
6 Commande() : ligne(NULL) {
7 ligne = new Ligne; // allocation de l’instance
8}
9 ~Commande() {
10 if(ligne != NULL)
11 delete ligne; // Libération de l’instance
12 }
13 Ligne getLigne() const {
14 return *ligne; // retourne une copie
15 }
16 };
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
62 / 63 en C++
 Références

Références

1 Thierry Vaira, "Cours Langage C/C++", BTS IRIS Avignon

2 https://laurent-audibert.developpez.com/Cours-UML/
3 Cours d’Éric REMY : http:
//pluton.up.univ-mrs.fr/eremy/Ens/Info1.C++/CM/C++.html
4 Cours et tutoriels C++ : http://cpp.developpez.com/cours/
5 Deitel et Deitel, "Comment programmer en C++", Editions G.
Reynald, 2001.
6 C. Delannoy, "Programmer en langage C++", 8ème Édition, Eyrolles,
2011.
7 Maude Manouvrier, Le langage C++, http:
//www.lamsade.dauphine.fr/~manouvri/C++/CoursC++_MM.html
8 Bjarne Stroustrup "Le Langage C++ (The C++ Programming
Language)", Addisson-Wesley – 4ème édition, mai 2013.
Année Universitaire : 2024/2025
Prof. Said El Kafhali Chapitre 2 : Classes, objets, attributs et méthodes
63 / 63 en C++