23/11/2020

Chapitre 3 :
Classe et Objet en C++

Les structures en C++

• En C, une structure est un type, définis par l’utilisateur qui contient
plusieurs éléments (membres) de différents types ( entiers, tableaux,
pointeurs, autre structure…)
struct point
{ // x et y sont les membres de la structure point
int x ;
int y ;
};
• C++ permet de lui associer des méthodes (fonctions membres)
struct point
{ // déclaration des données membres
int x ;
int y ;
// déclaration des fonctions membre (méthodes)
void initialise (int, int) ;
void deplace (int, int) ;
void affiche () ;
2
};
 23/11/2020

Déclaration d’une classe

• Déclaration de la classe :
o Regrouper la déclaration des attributs et des méthodes de la classe
o Se fait dans un fichier en-tête d’extension .h porte le nom de la classe

class Nom_classe
{
public :
// Déclaration des attributs et des méthodes publiques
private :
// Déclaration des attributs et des méthodes privées
};

• Les membres déclarés private ne seront plus accessibles de l’« extérieur » de la classe
• Les membres dits public sont accessibles partout
 Si aucun de ces deux mots n’apparaît au début de la définition, tout se passe comme si
private

Définition d’une classe

• Définition de la classe :
o Contient les définition des méthodes de la classe
o Se fait dans un fichier source d’extension .cpp porte le nom de la classe
o inclure la déclaration de la classe par une directive : #include " Nom_classe.h"

#include " Nom_classe.h"

// pour chaque méthode
type_retour Nom_classe : : nom_methode (paramètres)
{
// corps de la méthode
}

4
 23/11/2020

Utilisation d’une classe

• Utilisation d’une classe :
Création d’un nouvel objet
#include " Nom_classe.h" nom_objet de la classe Nom_classe
int main ( )  nom_objet est une instance de la
classe Nom_classe
{
Nom_classe nom_objet;
...
nom_objet.nom_attribut;
nom_objet.nom_methode(); L’accès aux données et
fonctions membres publics d’un
} objet

Structure du programme
• Les programmes en C++ sont organisés de la manière suivante :
o Pour chaque classe :
o Un fichier .h contenant sa déclaration ( attributs et prototype des méthodes )
o Un fichier .cpp contenant sa définition ( corps des méthodes)
o Un fichier .cpp contenant le traitement principal (fonction main)
class1.h class2.h
Class class1 Class class2
{ { Déclaration
…….. ……..
}; };

class1.cpp class2.cpp
# include "class1.h " main.cpp # include "class2.h " Définition
…………… # include "class1.h " ……………
# include "class2.h "
…………….
Void main()
{
…………… Utilisation
} 6
 23/11/2020

Exemple
// -------------------------- point.h------------------------------- // --------------------- point.cpp----------------------------
class point -
{ #include <iostream>
private : // facultatif #include " point.h "
int x ; using namespace std ;
int y ; void point : : initialise (int abs, int ord)
// déclaration des membres publics {
public : x = abs ;
void initialise (int, int) ; y = ord ;
void deplace (int, int) ; }
void affiche () ; void point : : deplace (int dx, int dy)
}; {
x = x + dx ;
// ------------------------- Main.cpp----------------------------- y = y + dy ;
#include " point.h " }
int main() void point : : affiche ()
{ point a, b ; // a et b sont des instances de la classe Point { cout << « Coordonnées du point : (" << x << " , "
a.initialise (5, 2) ; a.affiche () ; << y << ")" << endl ;
a.deplace (-2, 4) ; a.affiche () ; }
b.initialise (1,-1) ; b.affiche () ;
7
}

Notion de constructeur
• Au lieu d’utiliser une fonction initialise, nous allons voir un autre mécanisme de C++ :
les constructeurs
• Constructeur : est une méthode spécifique qui sera appelée automatiquement à
chaque création d’un objet permettant de l'initialiser
• Le constructeur porte le même nom que la classe et il ne retourne rien
• Une classe peut y avoir autant de constructeur que l’on veut, en fonction des besoins
 Le choix du bon constructeur se faisant suivant le nombre d’arguments
• Lorsqu’une classe ne comporte pas de constructeur, le compilateur génère un
constructeur par défaut
class A A : : A() //définition du constructeur
{ {
public : ………
A(); //déclaration d’un constructeur }
};

 Si une classe possède au moins un constructeur, on ne peut pas faire appel au constructeur par défaut
8
 23/11/2020

Notion de constructeur
• Exemple :
// -------------------------- point.h------------------------------- // --------------------- point.cpp-----------------------------
class point #include <iostream>
{ #include " point.h "
private : using namespace std ;
int x ; point : : point (int abs) // définition du constructeur 1
int y ; {
public : x = abs ;
point (int) ; // constructeur 1 (un argument) y = abs ;
point (int, int) ; // constructeur 2 (deux arguments) }
... point : : point (int abs, int ord)
}; { // définition du constructeur 2
x = abs ;
// ------------------------- Main.cpp----------------------------- y = ord ;
#include " point.h " }
int main() .. .
{
point a (3);
point b (1,2);
}
 Les initialisations des attributs peuvent se faire avec : att_1(val_1), . . . , att_n(val_n)
point : : point (int abs, int ord) : x(abs), y(ord) { } 9

Construction d’objets
• La création d'objets (opération d'instanciation) se fait en appelant le constructeur
• Un objet peut comporter des attributs statique, automatique et dynamique,
• Le rôle du constructeur est l’initialisation des attributs statiques et automatique ainsi
que l’allocation de la mémoire pour les attributs dynamiques
• Objets statiques et automatique : sont crées par une déclaration
Création d’une instance : NomClasse nomObjet; // acceptable s’il n’existe pas de constructeur ou
s’il existe un constructeur sans argument
Ou bien : NomClasse nomObjet( arguments);
L’accès : nomObjet.membre
• Objets dynamique :
Ils sont crées par un appel à l’opérateur new. On ne peux l’accéder qu'au travers d’un
pointeur
Création d’une instance : NomClasse* nomObjet = new NomClasse ;
Ou bien : NomClasse* nomObjet = new NomClasse( arguments);
L’accès : nomObjet ->membre 10
 23/11/2020

Construction d’objets
• Exemple :
// -------------------------- point.h------------------------------- // --------------------- point.cpp-----------------------
class point #include <iostream>
{ private : #include " point.h "
int x ; using namespace std ;
int y ; point : : point (int abs)
public : {
point (int) ; // constructeur 1 (un argument) x = abs ;
point (int, int) ; // constructeur 2 (deux arguments) y = abs ;
void deplace (int, int) ; }
void affiche () ; point : : point (int abs, int ord)
}; {
x = abs ;
// ------------------------- Main.cpp-----------------------------
y = ord ;
#include " point.h "
}
point a (3,4); // objet statique : déclarer en dehors de toute
.. .
fonction
int main()
{ point b (1,2); // objet automatique : déclarer dans une fonction
ou dans un bloc
point * ptr; // pointeur sur un point
ptr = new point(0); // objet dynamique
ptr -> deplacer(2,3);
ptr -> affiche () ; 11
}

Notion de destructeur
• Une méthode spécifique appelée automatiquement au moment de la destruction de
l’objet et qui permet de libérer l’espace mémoire occupé par les membres de l’objet
• Le destructeur porte le même nom que la classe, précédé d’un tilde (~)
• Il ne retourne rien et ne prend pas de paramètres
• Une classe ne comporte qu’un seul destructeur
• Lorsqu’une classe ne comporte pas de destructeur, le compilateur génère un par
défaut
• La définition explicite d’un destructeur n’est pas obligatoire lorsque tous les attributs
sont statique. Elle devient indispensable en cas d’attributs dynamiques.
• La libération des attributs dynamiques doit apparaitre explicitement dans le corps du
destructeur (avec l’opérateur delete)

12
 23/11/2020

Notion de destructeur
// --------------------- point.cpp-----------------------------
// -------------------------- point.h-------------------------------
...
class point
point : : point (int abs)
{
{
private :
x = abs ;
int x ;
y = abs ;
int y ;
}
public :
point : : ~ point ( ) // facultatif
point (int) ; // constructeur (un argument)
{
~point ( ) ; // destructeur
}
};
.. .

// --------------------- Etudiant.cpp--------------------------
// -------------------------- Etudiant.h-------------------------------
...
class Etudiant
Etudiant : : Etudiant (int id, int nb)
{
: ident (id), nbNotes (nb)
private :
{
int ident ;
notes = new float [nbNotes];
int nbNotes ;
}
float* notes;
Etudiant : : ~ Etudiant ( ) // indispensable
public :
{
Etudiant (int, int) ; // constructeur
delete [] notes; // libération
~ Etudiant ( ) ; // destructeur
}
}; 13
.. .

Destruction d’objets
• La destruction des objets statiques se fait automatiquement à la fin de l’exécution du
programme principal
• La destruction des objets dynamiques doit se faire explicitement avec l’appel à
l’opérateur delete
// -------------------------- Point.h------------------------------- // ------------------------- Main.cpp-----------------------------
class point ...
{ point a(1,1) ; // objet statique
private : int main()
int x ; { a.afficher();
int y ; point b(10,10) ; // objet automatique
public : for ( int i=1 ; i<=3 ;i++)
point(); { point c(i, 2*i); // objet automatique
point (int) ; // constructeur (un argument) c.afficher();
point (int, int) ; // constructeur (deux argument) } // destruction de c
~point ( ) ; // destructeur point* d = new point(4,5); // objet dynamique
... d-> afficher();
}; delete d; // destruction de d
} // destruction de b puis de a

14
 23/11/2020

Affectation d’objets
• Cas des objets statiques :
point a,b; b=a; // recopie des valeurs des attributs de a dans les attributs de b
• Cas des objets dynamiques :
point* a = new point (); a
a* : point
point* b; // a et b sont deux objets dynamique
b
b=a; // fait pointer b sur le même objet pointé par a
Remarque : une simple recopie avec = est insuffisante lorsque l’objet comporte des pointeurs sur des
emplacements dynamiques ( copie de l’adresse contenue dans le pointeur uniquement)

point p1(12, 25), p2; Etudiant e1(12, 25), e2;

p2=p1; e2=e1;
p1 : point p2 : point e1 : Etudiant e2 : Etudiant Problème
La copie est
Copie des superficielle, seule
x = 12 x = 12 id = 1 id = 1
valeurs des l’adresse contenue
nbNotes = 5 Copie des valeurs dans le pointeur est
attributs nbNotes = 5
y = 25 y = 25 des attributs copiée !
notes = @ notes = @
X
Objets ne contenant que des 15
attributs statiques Objets contenant que des attributs dynamiques

Constructeur de recopie
• Un constructeur de recopie :
Un constructeur spécial pour créer un objet à partir d’un autre objet (clone). Il permet
d’effectuer :
o Les allocations de mémoire nécessaire pour les attributs dynamique
o Les copies des valeurs des attributs dynamiques
• Cas d’utilisation :
o La création de copies d’un même objet
o Passage par valeur d’un objet à une fonction
o Retour par valeur d’un objet par une fonction
• Déclaration et définition :
nomClasse (nomClasse&); // déclaration du constructeur de recopie
nomClasse : : nomClasse(nomClasse& obj) : . . .
{
// copie des attributs dynamique
}
• Utilisation :
16
nomClasse nomclone = nomObjet; ou nomClasse nomClone (nomObjet);
 23/11/2020

Constructeur de recopie
• Exemple :
// --------------------- Etudiant.cpp--------------------------
// -------------------------- Etudiant.h------------------------------- ...
class Etudiant Etudiant : : Etudiant (int id, int nb) : ident (id), nbNotes (nb)
{ {
private : notes = new float [nbNotes];
int ident ; }
int nbNotes ; // définition du constructeur de recopie
float* notes; Etudiant : : Etudiant (Etudiant & e) : ident (e. ident),
public : nbNotes (e. nbNotes)
Etudiant (int, int) ; // constructeur {
Etudiant (Etudiant &) ; // déclaration du constructeur notes = new float [nbNotes];
de recopie for (int i=0 ; i < nbNotes ; i++)
}; * (notes+i) = * ((e.notes)+i);
}
int main()
{ Etudiant e1 (1,3);
Etudiant e2 (e1); e1 : Etudiant e2 : Etudiant La copie est
Etudiant e3=e1; profonde des
} id = 1 id = 1 attributs
Copie des valeurs dynamiques
nbNotes = 5 nbNotes = 5
des attributs
notes = @ notes = @’ 17

Le mot clé this

• Le mot clé this est pointeur constante qui réfère l’objet lui même
class point
{
private :
int x, y ;
public :
point (int , int ) ; // constructeur
void affiche () ; // Une fonction affiche
};
---------------------------------------------------------------------------------
void point : : affiche ()
{ cout << "Adresse : " << this << " - Coordonnees " << x << " " << y << "\n"
;
}
---------------------------------------------------------------------------------
int main() // Un petit programme d’essai
{ point a(5,1), b(3,15) ;
a.affiche ();
b.affiche (); Adresse : 0x709361348a20 - Coordonnees 5 1
} Adresse : 0x709361348a30 - Coordonnees 3 15

18
 23/11/2020

Le mot clé this

• On peut également utiliser this dans un constructeur recevant des valeurs d’initialisations, les mêmes
que les attributs de classe
class point ...
{ point : : point (int x, int y)
private : {
int x, y ;
this ->x = x ;
public :
point (int , int ) ; // constructeur this ->y = y ;
}; }

• Passer en paramétré la référence de l’objet lui même

class point
{
...
void f (. . .) {
g( * this) ;
}
void g( const point& a) { . . . }
};
19

Accès aux membres (visibilité)

• En POO, il est possible de préciser le type d’accès aux membres (attributs et
méthodes) d’un objet
• Cette opération s’effectue et s’applique au niveau des classes :
• Accès public : les membres publics peuvent être utilisés dans et par n’importe
quelle partie du programme

• Accès private : les membres privés d’une classe ne sont accessibles que par les
objets de cette classe et non par ceux d’une autre classe. Seule une méthode
membre de la même classe peut utiliser ce membre ; il est invisible de l’extérieur
de la classe

• Accès protected : comme les membres privés, mais ils peuvent en plus être utilisés
par une classe dérivée (notion d’héritage)

20
 23/11/2020

Règle d’encapsulation
• L’encapsulation est l’idée de protéger les variables contenues dans un objet et de ne
proposer que des méthodes pour les manipuler
• En respectant ce principe, tous les attributs d’une classe seront donc privés (private)
• On permettra un accès extérieur en lecture et/ou écriture via des méthodes appelées
accesseurs et mutateurs
• L’objet est ainsi vu de l’extérieur comme une « boîte noire » possédant certaines
propriétés (les attributs) et ayant un comportement (les méthodes) spécifié et
sécurisé
• C’est le comportement (ses méthodes publiques) d’un objet qui modifiera son état
(c’est-à-dire la valeur de ses attributs privés)
• L’ensemble des méthodes publiques forme l’interface

21

Accesseur (Get)/ Mutateur (Set)

• Pour chaque attributs privé, il faut créer des méthodes publiques pour y accéder et modifier
• Accesseur : méthode qui permet de lire la valeur d’un attribut
o Porte généralement un nom défini comme suit : getNomAttribut ()
o Retourne la valeur de l’attribut correspondant et ne prend pas d’arguments
• Mutateur : méthode qui permet de modifier la valeur d’un attribut
o Porte généralement un nom défini comme suit : setNomAttribut ()
o Modifier l’attribut correspondant avec une valeur passée en argument et ne retourne rien
class point // l’accesseur get de l’attribut x
{ int point: : getX() const
private : {
return x;
int x ;
}
public : // le mutateur set de l’attribut x
point (int) ; // constructeur void point: : setX( int x)
void affiche () const ; {
int getX() const ; // Accesseur this-> x=x;
void setX (int x); // Mutateur }
}; ...

Remarque : Les méthodes constantes sont des méthodes en « lecture seule ». Elle possèdent le mot clé const à la fin
de leur prototype et de leur déclaration  C'est le cas de la plupart des accesseurs 22
 23/11/2020

Attributs statiques
• Lorsque dans un même programme on crée différents objets d’une même classe, chaque objet possède ses
propres attributs
Exemple 1 :
class exple1 a.n b.n
{
int n ; a.x b.x
float x ; Objet a Objet b
.....
};
Exple1 a,b; // déclaration de deux objets

• Un attributs statique est un attribut partagé entre toutes les instances d’une classe
Exemple 2 :
class exple2
{ a.n b.n
static int n ;
a.x b.x
float x ;
..... Objet a Objet b
};
Exple2 a,b; // déclaration de deux objets
23

Attributs statiques
• Un attributs statiques n’existe qu’en un seul exemplaire, indépendamment des objets
de la classe
• Leur initialisation ne peut plus être faite par le constructeur de la classe
• Il doit donc être initialisé explicitement à l’extérieur de la déclaration de la classe en
utilisant l’opérateur de résolution de portée ::
int exple2 ::n = 5 ;
Exemple : Ajouter à la classe point un attribut permettant de compter le nombre des
instances existantes de la classe
class point Point : : point ( int n, int p) : x(p), y(p)
{ {
private : cpt ++;
static int cpt ; // attribut statique cout << « nombre d’objets : » << cpt << endl;
int x,y ; }
public : point : : ~point ()
point (int, int) ; // constructeur {
~point ( ) ; // destructeur cpt --;
}; cout << « nombre d’objets : » << cpt << endl;
int point: : cpt = 0; // initialisation de l’attribut statique
} 24
 23/11/2020

Méthodes statiques
• Une méthode statique est une méthode indépendante de toute instanciation de la
classe (objets)
• Une méthode statique ne peut manipuler que des attributs statiques
• Elle est appelée en utilisant le nom de la classe à la quelle elle appartient et
l’opérateur de résolution de portée :: (accès direct sans passer par une instance)
Exemple : Ajouter à la classe point une méthode permettant d’afficher le nombre de ses
instances existantes Point : : point ( int n, int p) : x(p), y(p)
{ cpt ++; }
class point point : : ~point ()
{ { cpt --; }
private : void point : : compter()
static int cpt ; // attribut statique {
int x,y ; cout << « nombre d’objets : » << cpt << endl;
public : }
point (int, int) ; // constructeur Int main ()
~point ( ) ; // destructeur { point: : compter ();
static void compter(); // méthode statique point a (1,6);
}; a. compter (); nombre d’objets :0
int point: : cpt = 0; // initialisation de l’attribut statique point b (3,5); nombre d’objets :1
point: : compter (); } nombre d’objets :2 25

Fonctions amies
• Encapsulation pure des données: attributs privés accessibles uniquement à travers les
méthodes publiques de la même classe.
• Pour faciliter l’accès d’une méthode non-membre de la classe aux attributs de cette
classe, on peut utiliser la notion de fonction amie
• Fonction amie : fonction extérieure à la classe mais autorisée à accéder aux attributs
privés au même titre que n’importe quelle fonction membre.
Syntaxe :
class maClasse
{ // attributs
public :
// méthodes
friend type_retour nom_fonction(arguments);
}

Moyen de contourner les mécanismes de contrôle d’accès (avantage/inconvénient)

26
 23/11/2020

Fonctions amies
Il existe plusieurs types d’amitié
 Fonction indépendante, amie d’une classe

27

Fonctions amies
 Fonction indépendante, amie de plusieurs classes
 Fonction membre d’une classe, amie d’une autre class
f : fonction membre de la classe B mais amie de la classe A

28
 23/11/2020

Fonctions amies
 Classe amie:
Toutes les fonctions d’une classe sont amies d’une autre classe

29

Fonctions amies
Exercice :
Ecrire un programme permettant de déterminer le produit d’une matrice (objet de classe matrice) par
un vecteur (objet de classe vect) à l’aide d’une fonction appelé « prod » qui retourne un objet de type
vect.
• La classe vect possède :
• Comme données : un vecteur de 3 éléments entiers
• Comme fonctions membres :
o un constructeur à 3 valeurs entiers
o une fonction d’affichage (affiche) pour afficher le contenu du tableau (vecteur)
• La classe matrice possède :
• Comme données : une matrice de 9 éléments entiers (3*3)
• Comme fonction membre :
o un constructeur ayant une matrice (3*3) comme paramètre

Ajouter la fonction amie nommée prod dans les deux cas suivants :
• prod est indépendante et amie des deux classes vect et matrice ;
• prod est membre de la classe matrice et amie de la classe vect.
30
 23/11/2020

Surcharge des opérateurs

 Généralités
 En langage C, l’opérateur division / est défini comme suit:
3/2  Division de deux valeurs entières
3,0/2,0  Division de deux valeurs réelles
 L’opérateur / est redéfini afin de réaliser deux types de division : une entière et une réelle.
 En langage C++, il est possible de redéfinir cet opérateur pour les classes.
 Pourquoi ?

 Afin de permettre de fournir aux utilisateurs des interfaces plus simples à manipuler.
31

Surcharge des opérateurs

 Surcharger un opérateur : lui permettre d’être appliqué et de se comporter
différemment avec divers types d’opérandes (objets).
 Pour surcharger un opérateur, on définit une fonction operator suivie du symbole
à surcharger.
 Une méthode membre de la classe à laquelle s’applique l’opérateur,
 Une fonction indépendante (éventuellement amie) avec cette classe.
Remarque:
• Les opérateurs qu’on peut surcharger : • Les opérateurs qu’on ne peut pas surcharger :
+ - * / ^ & | == != . opérateur de sélection d’un membre via objet
 : opérateur d’accès via pointeur .* opérateur pointeur vers un membre via objet
[] : opérateur d’indexation :: opérateur de résolution de portée
() : opérateur d’appel de fonction ?: opérateur conditionnel ternaire
new : opérateur d’allocation de mémoire sizeof opérateur déterminant la taille en octets
delete : opérateur de désaffectation de mémoire

32
 23/11/2020

Surcharge des opérateurs

Exemple : pour surcharger l’opérateur + et l’appliquer à des objets de type point
•

Résultats de l’exécution

33

Surcharge des opérateurs

•

Résultats de l’exécution

34
 23/11/2020

Surcharge des opérateurs

 Une expression telle que a + b est interprétée par le compilateur :
 On peut toujours écrire au lieu de
 Une expression telle que est évaluée selon les règles de priorité et d’associativité de
l’opérateur +. Cette expression est évaluée comme (a+b)+c:

 Cas de opérateurs ++ et --
 Notation préfixée ++a  Notation postfixée a++

 Besoin de définir à la fois un opérateur ++ utilisable en notation préfixée et postfixée.

 Une convention : ajouter un argument fictif à la version postfixée de la fonction
 Pour une fonction membre : notation préfixée
notation postfixée

L’argument de type int est totalement fictif, il permet uniquement au compilateur de choisir l’opérateur à
utiliser mais aucune valeur ne sera réellement transmise lors de l’appel.
35

Surcharge des opérateurs

 Pour une fonction indépendante : notation préfixée
notation postfixée
 Les mêmes considérations s’appliquent à l’opérateur --
Exemple :

Résultats de l’exécution

36
 23/11/2020

Surcharge des opérateurs x

a
y
 Cas de l’opérateur = 5
z
t
problème de l’affectation u

b
f
3
g
h

x
a
y
5
z
t

Après l’affectation u

b
f
3
g
37
h

Surcharge des opérateurs

Démarche pour une affectation b=a correcte
 Libération de l’emplacement pointé par b ;
 Création dynamique d’un nouvel emplacement dynamique dans lequel on recopie les valeurs de
l’emplacement pointé par a ;
 Copie des valeurs des attributs de b

x
y
5
a z
t
u

x
y
5
b z
t 38
u
 23/11/2020

Surcharge des opérateurs

Exercice :
Soit une classe vecteur3d définie comme suit :

class vecteur3d
{ float x, y, z ;
public :
vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0)
{ x = c1 ; y = c2 ; z = c3 ;
}
};

Définir les opérateurs == et != de manière qu’ils permettent de tester la coïncidence ou la

non-coïncidence de deux points :
a. en utilisant des fonctions membre;
b. en utilisant des fonctions amies.

39

Patrons de fonctions
Patron (template) de fonctions : modèle de fonction ou fonction générique  écrire une seul fois la définition
d’une fonction qui sera adapté automatiquement par le compilateur à n’importe quel type
Exemple :

Définir un patron de fonction minimum pour que ca soit applicable quelque soit le type
Résultat d’exécution :
min (n, p) = 4
min (x, y) = 2.5min (n, p) = 4
min (x, y) = 2.5

40
 23/11/2020

Patrons de fonctions

 template <class T> : il s’agit d’un patron (template) avec un paramètre de type nommé T
 Le mot-clé class pour préciser que T est un paramètre de type
 T minimum (T a, T b) : est une fonction recevant deux arguments de type T et fournissant un résultat du
même type T
 Le patron minimum peut être utilisé pour des arguments de n’importe quel type : un type prédéfini (short,
char, double, int *, char *, int * , etc.) ou d’un type défini par l’utilisateur (structure ou classe)

41

Patrons de fonctions

 Appliquer le patron minimum à

une classe  il est nécessaire que
l’opérateur < puisse s’appliquer à
deux opérandes de ce type classe

 Surcharge de l’opérateur <

Résultat d’exécution :
min (u, v) = 3 2
42
 23/11/2020

Patrons de classes
Patron (template) de classes : modèle de classe ou classe générique  écrire une seul fois la définition d’une
classe qui sera adapté automatiquement par le compilateur à n’importe quel type,
Exemple :

Création d’une instance

de la classe point
Définir un patron de classe point pour que ca soit applicable quelque soit le type  T prend la valeur int

Résultat d’exécution :
coordonnees : 3 5
coordonnees : d y
coordonnees : 3.5 2.3
43

Patrons de classes
Exemple : Créer un patron de classes permettant de représenter des « vecteurs dynamiques » (c’est-à
dire des vecteurs dont la dimension est inconnue). Les éléments de ces vecteurs puissent être de type
quelconque. On surdéfinira l’opérateur d’indexation [] pour qu’il permette l’accès aux éléments du
Vecteur.

Résultat d’exécution :
v : 0 1 2 3 44
 23/11/2020

Patrons de classes
Exemple : Soit la classe générique Triplet qui permet de garder trois valeurs de types différents et la
fonction principale suivante qui utilise une instance de la classe Triplet :

Résultat d’exécution :
etudiant :
11
Complétez la déclaration de la classe Triplet sans fournir les implémentations ali
13.5
de ses méthodes.
45

Classe String
 C++ fournit une classe standard pour la création et la manipulation des chaines de caractères : la classe string
 La taille d’un objet de type string peut évoluer dynamiquement au fil de l’exécution
 Constructeurs de la classe string :
o Construction d’une chaîne vide
string ch1 ;
o Construction d’une chaîne de 10 caractères
string ch2 (10, ’*’)
o Initialisation d’une chaine à partir d’une chaîne constante
string mess1 ("bonjour") ; // ou string mess1 = "bonjour" ;
o Initialisation à partir d’un tableau de caractère
char * adr = "salut" ;
string mess2 (adr) ; // ou string mess2 = adr ;

46
 23/11/2020

Classe String
 Les opérateurs <<,>> [], +, +=, =, ==, !=, <=, >=, <, > sont surchargés pour la classe string
 Fonction fréquemment utilisés:
o length() : fournit la taille de la chaîne
o find() : recherche d’une chaîne ou un caractères dans une chaîne ( 1 ere occurrence)
o insert () : inséré une chaîne ou un caractères dans une chaîne
o ecrase () : supprime un caractère ou une partie d’une chaîne
o replace() : remplacer une partie d’une chaîne par une autre

L’opérateur + a été surdéfini de

manière à permettre la concaténation :
• de deux objets de type string ;
• d’un objet de type string avec un
caractère

47