Programmation

Orientée
Objet
Abderrahmane Ouchatti
Prof Agrégé de Génie Electrique

2020/2021
 Plan
 Introduction & généralités
 Spécificités du Langage C++
 Notions de Classe et Objet.
 Propriétés des fonctions membres.
 Construction, destruction et initialisation des objets
 Les fonctions amies
 Surdéfinition des opérateurs
 Technique de l'héritage
 L’héritage multiple
 Polymorphisme
 Gestion des flux
 Les templates
 Gestion des exceptions 2
 Langages Objets
 C++
 Java
 C#,
 Python,
 PHP,
 Javascript
 …
les objets sont aussi utilisés pour :
▶ Bases de données objets (Oracle)
▶ Méthodes de modèlisation objets (UML)
▶ HTML+CSS, (accompagné de Javascript, PHP…)
3
 Introduction
Concepts qui donnent la puissance à la P.O.O.

 Concept de modélisation à travers la notion de classe

et d’instanciation de ces classes.

 Concept d’action à travers la notion d’envoi de messages et de

méthodes à l’intérieur des objets.

 Concept de construction par réutilisation et amélioration par

l’utilisation de la notion d’héritage

4
 Introduction & Généralités
POO – Avantages & Intérêts :

 Code plus sûr

 Programmes plus clairs
 Maintenance des applications est facilitée
 Code est facilement réutilisable
 Il est facile de créer de nouveaux algorithmes
légèrement différents par clonage d’un algorithme
existant
 Il est facile de faire évoluer des programmes
5
 Introduction & Généralités
Langages de programmation orientée objet
La programmation orientée objet est utilisée par les langages récents
de programmation les plus répondus.
Parmi ces langages:

C++,
Java, Gambas 3 SmallTalk (totalement objet)
Ada Java Delphi (=Pascal orienté objet)
C# Kylix PHP (Depuis la version 4)
D Objective-C Objective Caml (ocaml)
Fortran 2003 Perl Ruby
Python Visual Basic
6
 Introduction & Généralités
Langages de programmation orientée objet

 C++. 1983. Par Bjarne Stroustrup. S'appelait C with Classes jusqu'en 1983. Le
standard est C++ 98 auquel a succédé C++ 11 en 2011.

 C#. 2000. Par Microsoft comme alternative à Java et dérivé aussi de C++. C'est
un langage impératif et OO complet.

 Java. 1995. James Gosling and Sun. Fonctionnant sur machine virtuelle et donc
portable, il est dérivé de C avec objets. Chaque classe est stockée dans un fichier.

 PHP, Personal Home Page Hypertext Processor. 1995 by Rasmus Lerdof. PHP 5
en 2004. PHP 6 en 2007. Scripting coté serveur et générateur de pages.

 https://www.scriptol.fr/programmation/liste-langages-programmation.php

7
 Introduction & Généralités
Langages interprétés – langages compilés
Deux grands types de langages :
 les langages interprétés : Java (+ JavaScript), Python, PHP, …;
 les langages compilés : C, Pascal, C++, C#, ...

Langages interprétés

L'interprétation du code source est un

processus « pas à pas » : l'interpréteur va
exécuter les lignes du code une par une, en
décidant à chaque étape ce qu'il va faire
8
ensuite.
 Introduction & Généralités
Langages interprétés – langages compilés
Langages compilés

Dans ces langages, le code source est tout

d'abord compilé, par un logiciel qu'on
appelle compilateur, en un code
binaire qu'un humain ne peut pas lire mais
9
qui est très facile à lire pour un ordinateur.
 Introduction & Généralités
Langages compilés

10
 Introduction & Généralités
Langages interprétés – langages compilés
Principales différences :
 Avec un langage interprété, le même code source pourra
fonctionner directement sur tout ordinateur.

 Avec un langage compilé, il faudra tout recompiler pour chaque

système d’exploitation.

 Dans un langage compilé, le programme est directement

exécuté sur l'ordinateur, donc il sera en général plus rapide que
le même programme dans un langage interprété.

11
 Introduction & Généralités
Langages interprétés – langages compilés
Quelques exemples de langages couramment utilisés
Langage Domaine d'application principal Compilé/interprété
ADA Le temps réél Langage compilé
BASIC Programmation basique à but éducatif Langage interprété
C Programmation système Langage compilé
C++ Programmation système objet Langage compilé
Cobol Gestion Langage compilé
Fortran Calcul Langage compilé
Java Programmation orientée internet Langage intermédiaire
MATLAB Calcul mathématique Langage interprété
Mathematica Calcul mathématique Langage interprété
LISP Intelligence artificielle Langage intermédiaire
Pascal Enseignement Langage compilé
PHP Développement de sites web dynamiques Langage interprété
Prolog Intelligence artificielle Langage interprété
Perl Traitement de chaînes de caractères Langage interprété
12
POO – Langage C++

13
 Langage C++
Compilateurs C++
GCC Éditeur : GNU
GNU Compiler Collection, abrégé en GCC, est un ensemble de compilateurs créés par le
projet GNU. GCC est un logiciel libre capable de compiler divers langages de
programmation, dont C, C++, Objective-C, Java, Ada et Fortran. GCC est utilisé pour le
développement de la plupart des logiciels libres.

MinGW Éditeur : MinGW

MinGW ou Mingw32 (Minimalist GNU for Windows) est une adaptation des logiciels de
développement et de compilation du GNU (GCC - GNU Compiler Collection), à la plate-
forme Win32. Contrairement à Cygwin, les programmes générés avec MinGW n'ont pas
besoin de couche intermédiaire de compatibilité (sous forme d'une bibliothèque
dynamique, DLL). L'appellation Mingw32 a été abandonnée depuis que MinGW
supporte les environnements d'exécution 64 bits en plus du 32 bits.

14
 Langage C++
Environnement de développement intégré
Code::Blocks
• Logiciel libre de développement en C++.
• Licence : Gratuit OS : Windows XP Windows Vista Windows 7 Windows 8
Windows 10 Langue : EN Version : 17.12

De-C++
• Un environnement de développement gratuit pour le langage C++.
• Licence : Gratuit OS : Windows XP Windows Vista Windows 7 Windows
8 Langue :EN Version : 5.9.2

Visual Studio Community

• Environnement gratuit de développement en langage C++.
• Licence : Gratuit OS : Windows XP Windows Vista Windows 7 Windows 8
Windows 10 Langue : FR Version : 2017

15
 Spécificités du Langage C++

 Le C est inclus (à 99%) dans le C++

 Le C++ rajoute des notions de programmation orientée objet

(classe, héritage, polymorphisme… comme en Java), ainsi que
des facilités d’écriture (surcharge d’opérateurs…)

 C++ dispose d’un certain nombre de spécificités qui ne sont

pas obligatoirement relatives à la programmation orientée
objet.

16
 Spécificités du Langage C++
1. Commentaires

 Le texte placé entre les balises /* suivie de */ est commenté.

Ces balises peuvent éventuellement se trouver sur deux
lignes différentes.
 Si une ligne contient la balise // alors le texte de cette ligne
qui suit cette balise est commenté.
Exemple
//ceci est un commentaire.
int a; // déclaration de a.

2. Emplacement des déclarations main()

{
La déclaration des variables doit s’effectuer /*int a2= ;
for(int i=0;i
avant leur utilisation n’importe où dans un */
bloc ou dans une fonction. int a=7, b; b=a;
float x, y;
x=2*a+y; 17
}
 Spécificités du Langage C++
2. Emplacement des déclarations (portée / visibilité d’une variable)

La portée d’un identificateur correspond aux parties du programme

où cet identificateur peut être utilisé sans provoquer d’erreur à la
compilation.
La portée d’une variable globale ou d’une fonction globale est égale
au programme.
La portée d’une variable locale va de sa définition jusqu’à la fin de
la première instruction composée ({...}) qui contient sa définition.
Deux variables peuvent avoir le même nom mais dans ce cas, elle
doivent avoir deux portés différentes.
{
int i=3 ;
{
int i=5 ;
cout << i ; // affiche 5
}
cout << i ; // affiche 3 18
}
 Spécificités du Langage C++
3. Espace de nom (namespace):
• En C++, un espace de nom (namespace) est une notion permettant de lever
une ambiguïté sur des termes qui pourraient être homonymes.
• Il est matérialisé par un préfixe identifiant de manière unique la signification
d’un terme. On utilise alors l’opérateur de résolution de portée ::
• la notion d’espace de noms est aussi utilisée en Java, C# et dans les
technologies XML.
Exemple
#include <iostream>
using namespace std;
int main()
{
char a;
cout<<"Salam,"<<endl; // équivalent à std::cout<<"Salam,"<<endl;
printf("Exemle d'espace de noms 'std' ");
std::cin>> a;
return 0;
19
}
 Spécificités du Langage C++
4. Notion de référence:
• Transmission des arguments par valeur
• Transmission des arguments par adresse
• Transmission des arguments par référence
Exemple
void main()
{
void echange(int,int);
int a=2, b=5;
cout<<"Avant appel : "<<a<<" - "<<b<<" \n";
echange(a,b);
cout<<"Après appel : "<<a<<" - "<<b<<" \n";
getchar();
}
//-------------------------------------------------------
void echange(int m,int n)
{
int z; z=m; m=n; n=z; 20
}
 Spécificités du Langage C++
4. Notion de référence:
• Transmission des arguments par valeur
• Transmission des arguments par adresse
• Transmission des arguments par référence
Exemple
void main()
{
void echange(int *,int *);
int a=2, b=5;
cout<<"Avant appel : "<<a<<" - "<<b<< " \n ";
echange(&a,&b);
cout<<"Après appel : "<<a<<" - "<<b<< " \n ";
getchar();
}
//--------------------------------------------------------
void echange(int *x,int *y)
{
int z; z=*x; *x=*y; *y=z; 21
}
 Spécificités du Langage C++
4. Notion de référence:
• Transmission des arguments par valeur
• Transmission des arguments par adresse
• Transmission des arguments par référence
Exemple
void main()
{
void echange(int &,int &);
int a=2, b=5;
cout<<"Avant appel : "<<a<<" - "<<b<<"\n ";
echange(a,b);
cout<<"Apres appel : "<<a<<" - "<<b<<"\n ";
}
//----------------------------------------------------------
void echange (int & x,int & y)
{
int z; z=x; x=y; y=z;
} 22
 Spécificités du Langage C++
5. Arguments par défaut
• En C, il est indispensable que le nombre d’arguments passés correspond au
nombre d’arguments déclarés. C++ peut ne pas respecter cette règle.
Exemple
void main()
{
int m=1, n=5;
void f(int,int=7);
f(3,5);
f(4);
}
//-----------------------------------------------
void f(int a,int b)
{
cout<<"Valeur 1 : "<<a<<" - Valeur 2 : "<<b<<"\n";
}

23
 Spécificités du Langage C++
6. Surdéfinition de fonction (overloading)
• On parle de surdéfinition ou de surcharge lorsqu’un même symbole
possède plusieurs significations différentes, le choix de l’une des
significations se faisant en fonction du contexte. Pour pouvoir employer
plusieurs fonctions du même nom, il faut un critère permettant de choisir la
bonne fonction. En C++, ce choix est basé sur le type des arguments.
Exemple
void f(int x)
{ cout<<"fonction numéro 1 : "<<x<<"\n"; }
void f(double x)
{ cout<<"fonction numéro 2 : "<<x<<"\n"; }
void main()
{
int a=2; double b=5.7;
f(a); f(b); f('A');
}

24
 Spécificités du Langage C++
6. Surdéfinition de fonction (overloading)
Exemple 2  f(a, x); appellera la fonction f1.
void f(int, double); // f1  f(c, x); appellera la fonction f1 après
void f(double, int); // f2 conversion de c en int.
int a, b;  f(a, b); conduira à une erreur de
double x;
compilation (convertir a en double ou b en
char c ;
double).

Exemple 3  f(m, z); appellera la fonction f1.

void f(int a=0 ; double c=0); //f1
void f(double y=0 ; int b=0); //f2  f(z, m); appellera la fonction f2.
int m;  f (m); appellera la fonction f1.
double z ;
 f(z); appellera la fonction f2.
 f(); conduira à une erreur de
compilation.
25
 Spécificités du Langage C++
7. Opérateurs new et delete
• En langage C, la gestion dynamique de la mémoire a été assurée par les
fonctions malloc(…) et free(…). En C++, elle est assurée par les opérateurs
new et delete.
Exemples int *p;
char *t=new char [30];
p=new int;

int *p=new int; // Allocation dynamique d’un entier.

int *p2=new int[5]; // Allocation dynamique de 5 entiers.
char *t;
t=new char[30];

new fournit comme résultat :

- Un pointeur sur l’emplacement correspondant, lorsque l’allocation réussie.
- Un pointeur NULL dans le cas contraire.
delete possède deux syntaxes :
- delete p ;
- delete * +p ; Où p est une variable devant avoir comme valeur un pointeur sur un
emplacement alloué par new. 26
 Spécificités du Langage C++
8. fonctions en ligne (inline)
Une fonction en ligne se définit et s’utilise comme une fonction ordinaire, avec
la seule différence qu’on fait précéder son en-tête de la spécification inline.
Exemple
inline double norme(double vec[3])
{
for(int i=0,double s=0; i<3; i++) s=s+vec[i]*vec[i];
return sqrt(s);
}
//---------------------------------------------------------
main()
{
double V1[3], V2[3];
for (int i=0; i<3; i++) { V1[i]=i; V2[i]=i*3; }
cout<<"Norme de V1 est : "<<norme(v1);
cout<<" - Norme de V2 est : "<<norme(v2);
}

27
 Classes et Objets

Qu’est-ce qu’un Objet ?

Définition Générale:
« ce sur quoi porte notre connaissance »

Pour les technologies objet:

« c’est une abstraction du monde réel »

Pour l’analyse du domaine:

« c’est une entité pertinente du domaine »

Dans un langage de programmation OO:

« c’est un ensemble de fonctions associées à une structure de données »

Objet = État + Comportement + Identité

28
 Classes et Objets
Pourquoi l’approche objet ?

But:
 modélisation des propriétés statiques et dynamiques de l’environnement dans
lequel sont définis les besoins (domaine du problème),
 formalisation de la perception du monde et des phénomènes qui s’y déroulent,

Avantages:
capacité à :
 Regrouper ce qui a été séparé,
 Construire le complexe à partir de l’élémentaire,
 Intégrer statiquement et dynamiquement les constituants d’un système.

29
 Classes et Objets
Notation UML - Diagramme de classes

classe

attribut

Identifiant

Opération

Relation (Association)

généralisation / spécialisation

30
 Classes et Objets
Notion de classe
Une classe est une description abstraite (condensée) d’un ensemble
d’objets qui définit la structure (des données), leurs comportements et
leurs relations.

Nom de Classe
Attributs
Opérations () Moyen de transport
Type
Formalisme :
Poids
Couleur
Démarrer ()
Accélérer ()
Freiner ()

31
 Classes et Objets
Notion d’Objet

un objet est une instanciation (occurrence) d'une classe

Exemple
une personne, une voiture, une maison, ...

Caractérisation d’un objet

Identité FIAT-UNO-17 : Voiture
permet de le distinguer des autres objets
233434 : Numéro de série
1500 kg : Poids
Attributs 8864 YF 17 : Immatriculation
données caractérisant l'objet 133 000 : kilométrage

Méthodes Démarrer ()
Arrêter()
actions que l'objet est à même de réaliser Rouler()

32
 Classes et Objets
Notion de Classe – Objets

Voiture
Numéro de série : Int
Poids : double
Immatriculation : String
Kilométrage : double
FIAT-UNO-17
233434 : Numéro de série
1500 kg : Poids
8864 YF 17 : Immatriculation
33 000 : kilométrage

Démarrer ()
Arrêter()
Rouler()

Renault-Clio-17
5323454 : Numéro de série
1500 kg : Poids
64 YFT 17 : Immatriculation
23 000 : kilométrage
Peugeot-206-75
3434 : Numéro de série
1700 kg : Poids
8634 YGG 75 : Immatriculation
15 000 : kilométrage

33
 Classes et Objets

• Un objet est une entité informatique comprenant :

– des données membres (ou champs ou attributs ou
variables d’instances)
– des fonctions membres (ou méthodes ou routines)
On appelle encapsulation le regroupement des variables et
des fonctions au sein d'une même entité.

Données membres
Fonctions membres

Ex : un objet vecteur est composé de trois réels et d’opérations telles que la

translation, la norme, le produit scalaire …
• L'accès aux données et méthodes peut être réglementé :
.

Vision interne Partie privée

Partie publique Vision externe 34
 Classes et Objets
Exemples

DeuxRoues CompteBancaire
Nom de la classe
m_tailleRoues m_numéro
Vision m_nbVitesses Données membres Vision
m_solde
interne m_couleur ou attributs interne
m_propriétaire
m_poids Créditer()
Accélérer() Débiter()
Fonctions membres
Vision Freiner() Fermer() Vision
ou méthodes
externe ChangerVitesse() externe
Numéro()
GetCouleur() Solde()
GetPoids() Propriétaire()

35
 Classes et Objets

Propriétés d’un objet

• Un objet possède un état :
L’état correspond à la valeur de ses attributs à un instant donné. Il peut varier au
cours du temps.

• Un objet est décrit par une classe :

Une classe est un prototype qui définit des attributs et des méthodes communes à
tous les objets d'une certaine nature. C’est donc un modèle utilisé pour créer
plusieurs objets présentant des caractéristiques communes.

• Un objet possède une identité :

Les objets peuvent être distingués grâce à leurs existences inhérentes et non grâce
à la description des propriétés qu'ils peuvent avoir.
Deux objets peuvent être distincts même si tous leurs attributs ont des valeurs
identiques.
Ne pas confondre instance d'objet et classe d'objets
Une instance de classe fait référence à une chose précise
Une classe désigne un groupe de choses similaires
Ex : Le vélo de mon voisin et le mien sont deux instances de la classe vélo, même s’ils sont
strictement identiques 36
 Classes et Objets
class point // déclaration de la classe point
{
int x;
int y;
public :
void initialise(int,int);
void affiche();
void deplace(int,int);
};
//----Définition des fonctions membres-----
void point::initialise(int a,int b)
{ x=a; y=b; }
//-----------------------------------------
void point::affiche()
{ cout<<"on est à : "<<x<<" - "<<y<<endl; }
//-----------------------------------------
void point::deplace(int a,int b)
{ x=x+a; y=y+b; }
void main()
{
point p1, p2, p3;
p1.initialise(1,3); p1.affiche();
p1.deplace(2,4); p1.affiche();
p2.initialise(5,5); p2.affiche(); 37
}
 Classes et Objets
void main()
{
point p1, p2, p3;
p1.initialise(1,3); p1.affiche();
p1.deplace(2,4); p1.affiche();
p2.initialise(5,5); p2.affiche();
}
 On dit que p1 et p2 sont des instances de la classe ‘point’ ou encore que se sont
des objets de type ‘point’.
 Tous les membres données de ‘point’ sont privés ou encapsulés. Ainsi, on ne
peut pas accéder à x ou à y.
 Toutefois, les membres données ou les fonctions membres peuvent être privées
en utilisant le mot clé ‘private’ ou publiques en utilisant le mot clé ‘public’.

38
 Classes et Objets
class C
{
public :
………………………. ;
………………………… ;
private :
………………………… ;
………………………… ;
};
class point
{
int x, y;
public :
………………… ;
};
Affectation d’objets point p1, p2;

39
 Classes et Objets
Notion de constructeur et de destructeur
• Un constructeur est une fonction qui est appelée
automatiquement après la création d’un objet (quelque soit la
classe : statique, automatique ou dynamique).
• De la même façon, un objet possède un destructeur, fonction
membre qui est appelée automatiquement au moment de la
destruction de l’objet correspondant.
• Par convention, le constructeur se reconnaît à ce qu’il porte le
même nom que la classe. Quant au destructeur, il porte le même
nom que la classe précédé du symbole ~.
Règles
• Un constructeur peut ou non comporter quelques arguments.
• par définition, un constructeur ne renvoie pas de valeur et la présence de void (dans
ce cas précis) est une erreur.
• Un destructeur, par définition, ne peut pas disposer d’arguments et ne renvoie pas
de valeur. 40
 Classes et Objets
class demo
main()
{
{
int num ; void f(int);
public : demo obj(7);
demo(int); for (int i=0; i<4; i++)
~demo(); f(i);
}; }
//------------------ //-------------------------------
demo::demo(int n) void f(int m)
{ { demo obj(m) ; }
num=n;
cout<<″Appel constr numéro : ″<<num<<endl;
}
//---------------------------------------------
demo::~demo()
{
cout<<″Appel destr numéro : ″<<num<<endl;
}
//-------------------------------------- 41
 Classes et Objets
Autoréférence : le mot clé ‘this’
• Le mot clé ‘this’ utilisé uniquement au sein d’une fonction
membre désigne un pointeur sur l’objet l’ayant appelé.

class point
{
int x, y;
public :
point(int a=0,int b=0){ x=a; y=b; }
void affiche(){ cout<<"Point : "<<x<<" - "<<y<<"de
l’objet dont l’adresse est : "<<this<<endl; }
};
//------------------------------------------------------------
main()
{
point p1, p2(5,3), p3(6,70);
p1.affiche(); p2.affiche(); p3.affiche();
}
42
 Classes et Objets
Membres statiques
• Lorsqu’on crée différents objets d’une même classe, chaque objet
possède ces propres données membres.
• Pour pouvoir partager des données entre objets de la même
classe, on les déclare statiques.
 Les membres statiques existent en un seul exemplaire quelque soit le nombre
d’objets de la classe correspondante, et même si aucun objet de la même
classe n’a été créé.
 Les membres statiques sont toujours initialisés par 0.
class point
{
static int compteurPoint;
int x;
int y;
………………;
………………;
43
};
 Classes et Objets
Exercice
Ecrire un programme permettant de créer des objets ayant chacun :
• un tableau de 5 éléments de type entier en tant que donnée ;
• une fonction pour remplir le tableau, une fonction pour trier le
tableau et une fonction pour afficher le contenu du tableau en
tant que méthodes.

Exercice 2
Reprendre le même programme en remplaçant le tableau de 5
éléments par un tableau dynamique de ‘ne’ éléments et instancier
des objets ayant des tableaux dynamiques de différentes tailles.

44
 Fonctions amies
En principe, l’encapsulation interdit à une fonction membre d’une classe
ou toute fonction d’accéder à des données privées d’une autre classe.
Mais grâce à la notion d’amitié entre fonction et classe, il est possible, lors
de la définition de cette classe d’y déclarer une ou plusieurs fonctions
(extérieurs de la classe) amies de cette classe.
Une telle déclaration d’amitié les autorise alors à accéder aux données
privées, au même titre que n’importe quelle fonction membre.
Il existe plusieurs situations d’amitiés :
1. Fonction indépendante, amie d’une classe.
2. Fonction membre d’une classe, amie d’une autre classe.
3. Fonction amie de plusieurs classes.
4. Toutes les fonctions membres d’une classe, amies d’une autre classe.
47
 Fonctions amies
Pour déclarer une fonction amie d’une classe, il suffit de la déclarer dans
cette classe en la précédent par le mot clé ‘friend’.
1. Exemple de fonction indépendante amie d’une classe
class point
{ int x,y;
public :
point(int a=0,int b=0) {x=a; y=b;}
friend int coincide(point,point);
};//------------------------------------------
int coincide(point p1,point p2)
{ if(p1.x==p2.x && p1.y==p2.y) return 1; else return 0;
}//--------------------------
main()
{
point o1(15,2), o2(15,2), o3(13,25);
if(coincide(o1,o2)) cout<<"les objets coïncident\n";
else cout<<"les objets sont différents\n";
if(coincide(o1,o3)) cout<<"les objets coïncident\n";
else cout<<"les objets sont différents\n"; 48
}
 Fonctions amies
2. Fonction membre d’une classe, amie d’une autre classe
class B;
class A
{
…………………
public :
friend int B::f(int,A);
};
//------------------------------------------------
class B
{
…………………
public:
int f(int,A);
};
//-----------------------------------------------------
int B::f(int,A)
{
…………………
………………
49
}
 Fonctions amies
3. Fonction amie de plusieurs classes
Toute fonction membre ou indépendante, peut être amie de plusieurs classes.
class A
{
………………
public :
friend void f(A,B);
};//--------------------------------
class B
{
………………
public :
friend void f(A,B);
};//----------------------------
void f(A,B)
{
………
}
50
 Fonctions amies
4. Toutes les fonctions d’une classe sont amies d’une autre classe
Au lieu de faire autant de déclarations de fonctions amies qu’il y a
de fonctions membres, on peut résumer toutes ces déclarations en
une seule.
Exemple
‘friend class B;’ déclarée dans la classe ‘A’ signifie que
toutes les fonctions membres de la classe ‘B’ sont amies de la
classe ‘A’.
Remarque
Pour compiler la déclaration de la classe ‘A’, il suffit de la faire
précéder de : ‘class B; ‘ Ce type de fonction évite d’avoir à
déclarer, les entêtes des fonctions concernées par l’amitié.
51
 Fonctions amies
Exercice
Ecrire un programme permettant de réaliser le produit d’une matrice par un
vecteur à l’aide d’une fonction indépendante appelée ‘produit’ amie des
deux classes ‘matrice’ et ‘vecteur’.
La classe ‘vecteur’ possède :
- comme données : un vecteur de 3 éléments entiers.
- comme fonctions membres :
• Un constructeur à 3 valeurs entiers.
• Une fonction ‘affiche’ pour afficher le contenu du tableau (vecteur).
La classe ‘matrice’ possède :
- comme donnée : une matrice de 9 éléments (3x3).
- comme fonction membre : un constructeur ayant une matrice (3x3)
comme paramètre.
La fonction ‘produit’ retourne un objet de type ‘vecteur’ résultat du
produit d’une matrice par un vecteur. 52
 Fonctions amies
Exercice
Objectifs:
•Créer des fonctions amies (friend)
•Gérer l'amitié entre une fonction membre et une classe
Énoncé:
L'objectif de cet exercice est de calculer le produit d'une martice par un vecteur en
utilisant les fonctions amies.
1.Créer les deux classes suivantes :
1. l’une nommée vecteur, permettant de représenter des vecteurs à 3
composantes ; elle comportera un constructeur et une fonction
membre affiche.
2. L’autre nommée matrice, permettant de représenter des matrices carrées de
dimension 3x3 ; elle comportera un constructeur avec un argument (tableau
de 3x3 valeurs) qui initialisera la matrice avec les valeurs et une fonction
membre affiche.
2.Réaliser une fonction indépendante permettant de fournir le vecteur
correspondant au produit d’une matrice par un vecteur.
3.Réaliser une fonction membre à la classe vecteur permettant de fournir le vecteur
correspondant au produit d’une matrice par un vecteur.
4.Ecrire un programme de test.

53
 Fonctions amies
Exercice
On dispose d’un fichier nommé point.h contenant la déclaration suivante de
la classe point :
class point
{
float x, y ;
public :
void initialise (float abs=0.0, float ord=0.0) { x = abs ; y = ord ;}
void affiche () { cout << "Point de coordonnées : " <<x <<" "<< y<<"\n" ;}
float abs() { return x ;}
float ord() { return y ;}
};

a. Créer une classe pointb, dérivée de point comportant simplement une

nouvelle fonction membre nommée rho, fournissant la valeur du rayon vecteur
(première coordonnée polaire) d’un point.
b. Même question, en supposant que les membres x et y ont été déclarés
protégés (protected) dans point, et non plus privés.
c. Introduire un constructeur dans la classe pointb.
d. Quelles sont les fonctions membre utilisables pour un objet de type pointb ?
54
Exercice Fonctions amies
class vecteur; vecteur produit(matrice ma,vecteur
class matrice ve)
{ int m[3][3]; {
public : int i,j;
matrice(int ma[3][3]) vecteur vect;
{ for(int i=0;i<3;i++)
for(int i=0;i<3;i++) for(int j=0;j<3;j++)
for(int j=0;j<3;j++) vect.v[i]+=ma.m[i][j]*ve.v[j];
m[i][j]=ma[i][j]; return vect;
} }//-------------------------------
friend vecteur produit -----------
(matrice ma,vecteur ve); main()
};//------------------------------------------------
{
class vecteur vecteur v1(1,2,3);
{ int
int v[3]; mat[3][3]={1,2,3,4,5,6,7,8,9};
public : matrice m1(mat);
vecteur(int a=0,int b=0,int c=0) vecteur resultat;
{v[0]=a;v[1]=b; v[2]=c; resultat=produit(m1,v1);
} resultat.affiche();
void affiche() {for(int i=0;i<3;i++) getchar();
cout<<v[i]<<"\t"; }
}
friend vecteur produit(matrice ma,vecteur ve); 56
};//----------------------------------------------------------
 Surdéfinition des opérateurs

C++ autorise la surdéfinition des fonctions membres ou indépendantes en

fonction du nombre et du type d’arguments.
C++ autorise également la surdéfinition des opérateurs portant au moins
sur un objet, tel que l’addition (+), la soustraction (-) ou l’affectation (=)
entre objets.
1. Mécanisme de la surdéfinition des opérateurs
Pour surdéfinir un opérateur ‘op’, il faut définir une fonction de nom :
‘operator op’.

Exemple:
Point operator + (point,point);

57
 Surdéfinition des opérateurs

1. Surdéfinition d’opérateur avec une fonction amie

class point
{
int x,y;
point operator + (point p1,point p2) public:
{ point(int a=0,int b=0) {x=a; y=b;}
point p; void affiche()
{cout<<″Point: ″<<x<<″ - ″<<y<<endl;
p.x=p1.x+p2.x; }
p.y=p1.y+p2.y; friend point operator + (point,point);
return p; };
} //------------------------------------
//--------------------------
main()
{
point o1(10,20); o1.affiche();
point o2(45,50); o2.affiche();
point o3; o3.affiche();
o3=o1+o2; o3.affiche();
o3=operator+(o1,o2); o3.affiche();
o3=o1+o2+o3; o3.affiche();
o3=operator+(operator+(o1,o2),o3); o3.affiche();
58
}
 Surdéfinition des opérateurs
2. Surdéfinition d’opérateur avec une fonction membre
class point
{ int x,y;
public :
point(int a=0,int b=0) {x=a; y=b;}
void affiche() { cout<<"Point : "<<x<<" - "<<y<<endl; }
point operator + (point);
};//----------------------------------------------
point point::operator+(point p1)
{
point p;
p.x=x+p1.x; p.y=y+p1.y;
return p;
}//---------------------------
main()
{
point o1(10,20); o1.affiche();
point o2(40,50); o2.affiche();
point o3; o3.affiche();
o3=o1+o2; o3.affiche();
o3=o3+o1+o2; o3.affiche(); 59
}
 Surdéfinition des opérateurs

Possibilités et limites de surdéfinition des opérateurs en C++

 Il faut se limiter aux opérateurs existants
 Il faut conserver la pluralité (unaire, binaire) de l’opérateur initial.
 Lorsque plusieurs opérateurs sont combinés au sein d’une même
expression, ils conservent leurs priorités relatives et leurs associativités.

Choix entre fonction membre et fonction amie

Si un opérateur doit absolument recevoir un type de base en premier
argument, il ne peut pas être défini comme fonction membre (laquelle
reçoit implicitement un premier argument du type de sa classe).

60
 Surdéfinition des opérateurs
Possibilités et limites de surdéfinition des opérateurs en C++
Pluralité Opérateur Associativité
Binaire ( )͌ [ ] ͌ →͌ →
Unaire + - ++ -- ! & new͌ delete͌ 
Binaire */% →
Binaire +- →
Binaire << >> →
Binaire < <= > >= →
Binaire == != →
Binaire & (niveau bit) →
Binaire ^ (ou exclusif) →
Binaire || →
Binaire && →
Binaire | (niveau bit) →
Binaire =͌ += -= *= /= %= &= ^= |= <<= >>= 
Binaire , →
͌ : opérateur devant être surdéfini en tant que fonction membre.
61
 Surdéfinition des opérateurs

Exemple de surdéfinition de l’opérateur ‘-’

Surdéfinir l’opérateur ‘-’ de manière à ce que ‘p1-p2’ désigne le vecteur
définit par les points p1 et p2.

Exemple de surdéfinition de l’opérateur ‘+’

Surdéfinir l’opérateur ‘+’ de manière à ce que ‘v1+v2’ désigne le vecteur
résultant de la somme des deux vecteurs v1 et v2.

Exemple de surdéfinition de l’opérateur ‘=’

Exemple de surdéfinition de l’opérateur ‘* +’

Surdéfinir l’opérateur ‘* +’ de manière à ce que ‘o*i+’ désigne l’élément du
tableau dynamique d’emplacement ‘i’ de l’objet ‘o’ de la class ‘tableau’. Le
premier opérande de ‘o*i+’ étant ‘o’. 62
 Relations entre Classes

Notion de relations entre Classes

Étant donné qu’en POO les objets logiciels interagissent entre

eux, il y a donc des relations entre les classes.
On distingue cinq différents types de relations de base entre les
classes :
• l’association (trait plein avec ou sans flèche)

• la composition (trait plein avec ou sans flèche et un losange plein)

• l’agrégation (trait plein avec ou sans flèche et un losange vide)

• la relation de généralisation ou d’héritage (flèche fermée vide)

• la dépendance (flèche pointillée)

63
 Relations entre Classes

La Relation d’association
Une association représente une relation sémantique durable entre
deux classes. Les associations peuvent donc être nommées pour donner
un sens précis à la relation.

64
 Relations entre Classes

La relation d’agrégation
Une agrégation est un cas particulier d’association non symétrique
exprimant une relation de contenance. Les agrégations n’ont pas besoin
d’être nommées : implicitement elles signifient «contient» ou «est
composé de».

65
 Relations entre Classes

La relation de composition
Une composition est une agrégation plus forte signifiant « est composée
d’un » et impliquant :
– une partie ne peut appartenir qu’à un seul composite (agrégation non partagée)
– la destruction du composite entraîne la destruction de toutes ses parties (il
est responsable du cycle de vie de ses parties).

66
 Relations entre Classes
La relation d’héritage
L’héritage est un concept
fondamental de la programmation
orientée objet. Elle se nomme ainsi car
le principe est en quelque sorte le même
que celui d’un arbre généalogique. Ce
principe est fondé sur des classes
«filles» qui héritent des caractéristiques
des classses «mères».
L’héritage permet d’ajouter des
propriétés à une classe existante pour
en obtenir une nouvelle plus précise. Il
permet donc la spécialisation ou la
dérivation de types.
67
 Relations entre Classes
La relation d’héritage

L’héritage est une relation entre classes qui a les propriétés suivantes :
– si B hérite de A et si C hérite de B alors C hérite de A
– une classe ne peut hériter d’elle-même
– si A hérite de B, B n’hérite pas de A
– il n’est pas possible que B hérite de A, C hérite de B et que A hérite de C
– le C++ permet à une classe C d’hériter des propriétés des classes A et B
(héritage multiple). 68
 Relations entre Classes
La relation d’héritage –Droits d'accès sur les membres hérités

Le C++ permet de préciser le type d’accès des membres (attributs et

méthodes) d’un objet. Cette opération s’effectue au sein des classes de
ces objets.
Il faut maintenant tenir compte de la situation d’héritage :
– public : les membres publics peuvent être utilisés dans et par n’importe
quelle partie du programme.
– privé (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 même dérivée.
– protégé (protected) : les membres privés d’une classe ne sont
accessibles que par les objets de cette classe et par ceux d’une
classe dérivée.
69
 Relations entre Classes
La relation d’héritage –Droits d'accès sur les membres hérités

mot clé utilisé pour l'héritage

Accès aux données public protected private

public public protected private

mot clé utilisé
pour les
protected protected protected private
champs et les
méthodes
private interdit interdit interdit

70
 Relations entre Classes
La relation d’héritage – Exemple

71
 Relations entre Classes
La relation d’héritage – Conclusion :

En utilisant l’héritage, il est donc possible d’ajouter des

caractéristiques, d’utiliser les caractéristiques héritées et de
redéfinir les méthodes héritées.
Généralement, cette redéfinition (overriding) se fait par surcharge
et permet de modifier le comportement hérité. Voir aussi le
polymorphisme.

72
 Technique de l'héritage

Notion d’héritage
• L'héritage est un principe propre à la POO qui permet de créer une nouvelle
classe à partir d'une classe existante. La classe nouvellement créée, dite classe
dérivée, contient les attributs et les méthodes de la classe dont elle dérive,
auxquelles s’ajoutent de nouveaux attributs et de nouvelles méthodes propres
à la classe dérivée.

• L’héritage permet donc de définir une hiérarchie de classes :

– La classe de base est une classe générique.
– Les classes dérivées sont de plus en plus spécialisées

classe de base ou classe mère ou

Deux roues
classe parente

classes
Sans moteur A moteur dérivées ou
classes filles

Vélo Patinette Moto Scooter Mobylette

73
 Technique de l'héritage

Notion d’héritage
• La P.O.O. permet de définir de nouvelles classes (classes filles) dérivées de
classes de base (classes mères), avec de nouvelles potentialités. Ceci permettra
à l’utilisateur, à partir d’une bibliothèque de classes donnée, de développer
ses propres classes munies de fonctionnalités propres à l’application.
On dit qu’une classe fille DERIVE d’une ou de plusieurs classes mères.

Héritage simple Héritage multiple 74

 Technique de l'héritage
Exemple class vecteur // classe mère
{
float x,y;
public: void initialise(float,float);
void homothetie(float);
void affiche();
};
void vecteur::initialise(float abs =0.,float ord = 0.)
{
x=abs;y=ord;}
void vecteur::homothetie(float val)
{x = x*val; y = y*val;
}
void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}
class vecteur3:public vecteur // classe fille
{
float z;
public:
void initialise3(float,float,float);
void homothetie3(float);
void hauteur(float ha){z = ha;}
void affiche3();
}; 75
 Technique de l'héritage Exemple
void vecteur3::initialise3(float abs=0.,float ord=0.,float haut=0.)
{
initialise(abs,ord); z = haut;
} // fonction membre de la classe vecteur

void vecteur3::homothetie3(float val)

{homothetie(val); z = z*val;} // fonction membre de la classe vecteur

void vecteur3::affiche3()
{affiche();cout<<"z = "<<z<<"\n";} // fonction membre de la classe vecteur

void main()
{
vecteur3 v, w;
v.initialise3(5, 4, 3);v.affiche3();// fonctions de la fille
w.initialise(8,2);w.hauteur(7);w.affiche();// fonctions de la mère
cout<<"*******************************\n";
w.affiche3();w.homothetie3(6);w.affiche3();// fonctions de la fille
getch() ;
}

76
 Technique de l'héritage Exemple
class vecteur // classe mère
{
float x,y;
public: void initialise(float,float);
void homothetie(float);
void affiche();
};
void vecteur::initialise(float abs =0.,float ord = 0.)
{x=abs;y=ord;}
void vecteur::homothetie(float val)
{x = x*val; y = y*val;}
void vecteur::affiche()
{cout<<"x = "<<x<<" y = "<<y<<"\n";}

class vecteur3:public vecteur // classe fille

{
float z;
public:
void initialise(float,float,float);
void homothetie(float);
void hauteur(float ha){z = ha;}
void affiche();
} ;
77
 Technique de l'héritage Exemple
void vecteur3::initialise(float abs=0.,float ord=0.,float haut=0.)
{vecteur::initialise(abs,ord); z = haut;} // fonction membre de la classe
vecteur
void vecteur3::homothetie(float val)
{
vecteur::homothetie(val); // fonction membre de la classe vecteur
z = z*val;}
void vecteur3::affiche()
{
vecteur::affiche(); // fonction membre de la classe vecteur
cout<<"z = "<<z<<"\n";}

void main()
{
vecteur3 v, w;
v.initialise(5, 4, 3);v.affiche();
w.initialise(8,2); w.hauteur(7);
w.affiche();
cout<<"*******************************\n";
w.affiche();
w.homothetie(6);w.affiche();
getch() ;
}
78
 Technique de l'héritage Exercices
A partir de l’exemple précédent, créer un projet. La classe mère sera considérée
comme une bibliothèque. Définir un fichier mere.h contenant les lignes suivantes :

class vecteur // classe mère

{
float x,y;
public: void initialise(float,float);
void homothetie(float);
void affiche();
};
Le programme utilisateur contiendra la définition de la classe fille, et le programme
principal.

Exercice :
Dans le programme principal précédent, mettre en œuvre des pointeurs de vecteur.
Remarque :
L’amitié n’est pas transmissible: une fonction amie de la classe mère ne sera amie
que de la classe fille que si elle a
été déclarée amie dans la classe fille.

79
 Polymorphisme

Notion de polymorphisme
• Une classe dérivée peut fournir une nouvelle définition d’une méthode d'une
classe parent car elle peut avoir besoin de réagir différemment à l'appel de cette
méthode. Cette redéfinition substituera une méthode à une autre : c’est la
spécialisation.
• La notion de polymorphisme signifie que, la même opération pouvant se
comporter différemment sur différentes classes de la hiérarchie, il est
possible d'appeler la méthode d'un objet sans se soucier de son type intrinsèque.
Ceci permet de faire abstraction des détails des classes spécialisées d'une famille
d'objet, en les masquant par une interface commune (qui est la classe de base).
Velo
DeuxRoues
m_typePedale
m_tailleRoues
GetTypePedale()
m_couleur
virtual Accélérer()
m_poids
virtual Freiner()
m_nbVitesses virtual ChangerVitesse()
Moto
virtual Accélérer()
m_moteur
virtual Freiner() La fonction Accélérer() n’est pas la même
virtual ChangerVitesse() m_boiteVitesse
FairePlein() pour un Velo et une Moto. La redéfinition
GetCouleur()
AllumerClignotant() de cette fonction dans chacune des sous-
GetPoids()
virtual Accélérer() classes entraînera un comportement
virtual Freiner() différent suivant que le DeuxRoues est un
virtual ChangerVitesse() Velo ou une Moto. 80