La Programmation Orientée Objet

en Langage C++

Brahim EL FALAKI ENSMR ‘16

De C à C++
Fonctions sans valeur de retour Les arguments par défaut Gestion dynamique de la mémoire …

Fonctions sans arguments La transmission par référence …

Différence
Le qualificatif const …. entre Nouvelles possibilités d’entrées-sorties ...
C et C++

Emplacement libre des déclarations

Le type void * …..

Les fonctions en ligne

Orientée Objet
Programmation Orientée Objet
1- Classe et Objets
La Programmation Orientée Objet: Introduction

Fiche de Paie Fiche de Paie Fiche de Paie Fiche de Paie

Matricule: 1235 Matricule: 456 Matricule: 987 Matricule: 365

Nom: Alami Nom: Bennani Nom: Slimani Nom: Ibrahimi
Prénom: Mohamed Prénom: Ali Prénom: Ahmed Prénom: Hakim
Echelle: 11 Echelle: 10 Echelle: 10 Echelle: 8
Nombre enfant: 3 Nombre enfant: 1 Nombre enfant: 2 Nombre enfant: 5
Nbre_an_tr: 12 Nbre_an_tr: 10 Nbre_an_tr: 16 Nbre_an_tr: 18

Allocation Familiale:400 Allocation Familiale:200 Allocation Familiale:350 Allocation Familiale:500

Salaire:9300 Salaire:8200 Salaire:7950 Salaire:7900

Fiche de Paie

Matricule:…..
Nom:…………
Prénom:………….
Echelle:…….
Nombre enfant:………..
Nbre_an_tr:………..

Allocation Familiale:
Salaire:
La Programmation Orientée Objet: Introduction

Matricule: 1235 Matricule: 456 Matricule: 987 Matricule: 365

Nom: Alami Nom: Bennani Nom: Slimani Nom: Ibrahimi
Prénom: Mohamed Prénom: Ali Prénom: Ahmed Prénom: Hakim
Echelle: 11 Echelle: 10 Echelle: 10 Echelle: 8
Nombre enfant: 3 Nombre enfant: 1 Nombre enfant: 2 Nombre enfant: 5
Nbre_an_tr: 12 Nbre_an_tr: 10 Nbre_an_tr: 16 Nbre_an_tr: 18

Employe

Matricule
Nom
Prénom
Echelle
Nombre enfant
Nbre_an_tr

Calc_ALLF()
Calc_Sal()
La Programmation Orientée Objet: Classe, Objet (1/4)

Classe:
 Une classe est un moule d'objets .
 Une Classe décrit les attributs et les méthodes de toute une famille d'objets.
 Les objets d'une même classe ont les mêmes attributs, mais avec des valeurs différentes.

Personne Nom de la classe class Personne {

public :
+Nom Données membres ou string nom;
+Societe attributs
string societe;
+Presentetoi() void presenteToi( ) {
Fonctions membres ou cout << "je suis " << nom << endl ;
méthodes
cout << "je travaille à " << societe << endl ;
}
};
La Programmation Orientée Objet: Classe, Objet (2/4)

Syntaxe: forme générale

class <nom de classe>

{
public:
// déclaration des attributs <type> <identificateur d’attribut>;
// prototype et définition des méthodes
<type> <identificateur>(<arguments>)
Private: {
// déclaration des attributs <corps de la fonction>
// prototype et définition des méthodes [return <valeur>]
}; }
La Programmation Orientée Objet: Classe, Objet (3/4)

Objet:
 Un objet est une instance (une entité identifiable, un exemplaire) d’une classe.

 Il regroupe des données membre (les attributs) et des fonctions membre (les méthodes).

 Les méthodes sont des fonctions qui s'appliquent à l'objet et à ses attributs

CompteBancaire C1, un objet de la classe CompteBancaire

m_numéro 5478952 250 326,00 Bennani
m_solde
m_propriétaire m_numéro m_solde m_propriétaire
Créditer(float)
Débiter(float)
Fermer()
Numéro()
Solde()
Propriétaire() C2, un objet de la classe CompteBancaire
4778933 2 326,00 KHALIDI
m_numéro m_solde m_propriétaire

Mémoire virtuelle
La Programmation Orientée Objet: Classe, Objet (4/4)

Objet:
 Un objet est une instance (une entité identifiable, un exemplaire) d’une classe.

 Il regroupe des données membre (les attributs) et des fonctions membre (les méthodes).

 Les méthodes sont des fonctions qui s'appliquent à l'objet et à ses attributs
P1, un objet de la classe Personne
Une personne possède un nom et Personne
appartient à une société . Ibrahimi ATOS
Une personne a un seul +Nom
nom societe
comportement : se présenter en +Societe
disant:
Je suis xx et je travaille à yyyy +Presentetoi()

Instanciation
class Personne {
public :
Utilisation de la classe
int main()
string nom;
string societe; {
Personne P1;
void presenteToi( ) { P1.nom= " Ibrahimi" ;
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;
P1.societe= " ATOS" ;
} P1.presenteToi( );
}; }

DevC++
La Programmation Orientée Objet: Instanciation

Instanciation
 L'instanciation : l'action de faire appel à un constructeur pour créer un objet à partir d'une classe.
 Elle est réalisée par la composition de deux opérations :
• Allocation: consiste à réserver un espace mémoire au nouvel objet.

• Initialisation: consiste à fixer l'état du nouvel objet.

Personne P1, un objet de la classe Personne

+Nom
Instanciation Ibrahimi ATOS
+Societe

+presentetoi()

Mémoire virtuelle
La Programmation Orientée Objet: Constructeur

Un constructeur est une fonction-membre

 Possède le même nom que la classe.
 N’a pas de type de retour et sans mot clé void.

Constructeur spécial

1. Constructeur par Défaut :

Si (une classe ne contient pas de façon explicite un constructeur ) Alors :
le compilateur ajoute automatiquement un constructeur sans paramètres
2. Constructeur par recopie
Le rôle d'un constructeur par copie est de permettre l'instanciation d'un nouvel objet dans le
même état qu'un objet existant (ou clone). (peut être redéfini)
Si (une classe ne contient pas de façon explicite un constructeur par recopie ) Alors :
le compilateur ajoute automatiquement un constructeur par recopie par défaut.
Déclaration nom_classe (const nom_classe & p);
Invoqué par X* x = new X(y);
X x = y;
X x(y);
Lors du retour d'une fonction retournant un objet par valeur
Lors du passage d'un objet par valeur à une fonction.
La Programmation Orientée Objet: Constructeur par défaut

#include<iostream>
#include<string>
using namespace std;
class Personne {
public :
string nom;
string societe;

Personne(){
nom="pers";
societe="??";
}

Personne(string a, string b){

nom=a;
societe=b;
}

void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;
}
};
int main()
{
Personne P1("Hachimi","CompInfo") ;
P1.presenteToi( );
Personne P2;
P2.presenteToi( );
system("pause");
} Dev C++
La Programmation Orientée Objet: Constructeur par recopie (1/2)

#include<iostream>
#include<string>
using namespace std; Constructeur par recopie (par défaut)
class Personne {
int main()
public :
string nom; {
string societe; Personne P1(" Mohamed ", " Arkeos ");
Personne P5(" Ali ", " ENR ");
Personne(){ P1.presenteToi( );
nom="pers"; Personne P2=P1;
societe="??"; P2.presenteToi( );
}
Personne P3(P1);
Personne(string a, string b){ P3.presenteToi( );
nom=a; Personne* P4=new Personne(P5);
societe=b; P4->presenteToi( );
} delete P4;
system("pause");
void presenteToi( ) { }
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;
}
};

Dev C++
La Programmation Orientée Objet: Constructeur par recopie (2/2)

#include<iostream>
#include<string>
using namespace std; Constructeur par recopie
class Personne {
int main()
public :
string nom; {
string societe; Personne P1(" Mohamed ", " Arkeos ");
Personne P5(" Ali ", " ENR ");
Personne(){ P1.presenteToi( );
nom="pers"; Personne P2=P1;
societe="??"; P2.presenteToi( );
}
Personne P3(P1);
Personne(string a, string b){ P3.presenteToi( );
nom=a; Personne* P4=new Personne(P5);
societe=b; P4->presenteToi( );
} delete P4;
Personne (Personne & P){ system("pause");
nom= P.nom; }
societe=P.societe;
}
void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;
}
};
 ptr_5
La Programmation Orientée Objet: Constructeur @

Mohamed

P6

P4
Personne* Ptr_5=new Personne(P2); Ahmed Arkos

Personne Personne P6(P1);

ptr_ps
+ nom Personne P4=P3; @
+ societe

Ali PN
+ presentetoi()
+Personne(string,string) Personne* ptr_ps = new Personne(("Ali", "PN " );
+Personne(string) P3
+Personne() Ahmed Arkos

P2
Personne P3("Ahmed", "Arkos");
Mohamed
Personne P2("Mohamed");
P1
Personne P1;

Mémoire Virtuelle
La Programmation Orientée Objet: Le cycle de vie d’un objet Création Vie Mort

Un objet occupe de l'espace en mémoire. Il peut être alloué :

 Allocation Statique d’un objet: Déclaration Vie Fin Portée

 La durée de vie est limitée au contexte dans lequel il est déclaré

 En général le corps d'une fonction ou méthode

Personne P1 ("Hachimi", "SQLi");

Personne groupe[ 5 ]; // groupe est tableau de 5 objets 'Personne'.

 Allocation Dynamique d’un objet: new Vie delete

L'objet est (persistant). On le désalloue en utilisant l'opérateur delete

Un pointeur sur la zone mémoire de l'objet a été alloué est retourné
Personne* ptr_pers = new Personne(("Hachimi", "SQLi " ); Création

ptr_pers ->presenteToi( ); Vie

delete ptr_pers ; // (Le destructeur de l'objet est appelé) Mort

La Programmation Orientée Objet: Objet Dynamique

#include <iostream>
using namespace std ;
class point
{ int x, y ;
public :
point (int abs, int ord)
{ x=abs ; y=ord ;
cout << "++ Appel Constructeur \n" ; }
~point (){
cout << "-- Appel Destructeur \n" ;}
};
main()
{ void fct (point *) ;
point * adr ;
cout << "** Debut main *******\n" ;
adr = new point (3,7) ;
fct (adr) ;
cout << "** Fin main**** \n" ; }
void fct (point * adp)
{ cout << "** Debut fct**** \n" ;
delete adp ; // destruction de cet objet
cout << "** Fin fct \n" ;
}

Dev C++
La Programmation Orientée Objet: Destructeur

Un destructeur est une fonction-membre

 Même nom que la classe précédée de tilda (~) ~nom classe();
 Sans type ni paramètre ni void
 Ne prend aucun paramètre.
 Un seul destructeur, et ne peut être surchargé.
 A l’issue de l’exécution d’un bloc, le destructeur est automatiquement appelé pour chaque objet de la
classe déclaré dans ce bloc
 #include<iostream>
La Programmation Orientée Objet: Destructeur #include<string>
using namespace std;
class Personne {
int main() private:
{ string nom;
string societe;
Personne individu ("Bennani","CompInfo"); public :
individu.presenteToi( ); Personne(){
Personne individu1 ; nom="pers";
individu1.presenteToi( ); societe="??";
individu.~Personne(); }
individu1.presenteToi( ); Personne(string a, string b){
//individu.presenteToi( );//erreur nom=a;
system("pause"); societe=b;
return 0 ; }
} ~Personne(){
cout<<" terminé "<<" \n ";
}
void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;
}
};

Dev C++
Exploitation d’une classe
Structure d’un programme en C++

Structure d’un programme

class point
{

Déclaration
int x ;
int y ;
public :
point (int, int) ;
void deplace (int, int) ;
void affiche () ;
}; point.h

#include <iostream>

Utilisation
#include "point.h"
using namespace std ;

point::point (int abs, int ord)

{ x = abs ; y = ord ;

Définition
}

void point::deplace (int dx, int dy)

{ x = x + dx ; y = y + dy ;
}
Main.cpp

void point::affiche ()
{ cout << "Je suis en " << x << " " << y << "\n" ;
} point.cpp
Dev C++
La compilation d’un Programme C++
Programmation Orientée Objet
2- Les propriétés des fonctions membres
La Programmation Orientée Objet: Sur-définition des fonctions membres

 Signature d’une fonction: la signature d’une fonction est déterminée par:

1- le nom de la fonction
2- le nombre de ses paramètres
3- le type de ses paramètres
La Programmation Orientée Objet: Sur-définition des fonctions membres

#include <iostream> #include <iostream>

#include <string> #include <string>
using namespace std ; #include "point.h"
class point using namespace std ;
{ int x, y ; point::point ()

Déclaration
{ x = 0 ; y = 0 ;}
public :
point () ;

Définition
point::point (int abs)
point (int) ; { x = y = abs ;}
point (int, int) ;
void affiche () ; point::point (int abs, int ord)
void affiche (string) ; { x = abs ; y = ord ; }
};
void point::affiche ()
point.h { cout << "Je suis en : " << x << " " << y << "\n" ;}

void point::affiche (string message)

{ cout << message ; affiche () ;} point.cpp

Utilisation
#include "point.h"
main()
{ point a ;
a.affiche () ;
point b (5) ;
b.affiche ("Point b - ") ;
point c (3, 12) ;
c.affiche ("Hello ---- ") ;
system("pause");
} main.cpp
Dev C++
La Programmation Orientée Objet: Sur-définition des fonctions membres

Argument par défaut

 Les fonctions membres peuvent disposer d’arguments par défaut (lors de la déclaration uniquement
 Remplace plusieurs fonctions surdéfinies par une seule fonction ayant un argument par défaut
#include<iostream> Exemple1
#include<string>
using namespace std;
class Personne {
private:
string nom;
string societe;
public :

Personne(string a= " Inconnu ", string b= " Sans ")

{
nom=a;
societe=b;
}
void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;
}
};
La Programmation Orientée Objet: Sur-définition des fonctions membres

#include <iostream> #include <iostream>

#include <string> #include <string>
using namespace std ;
#include "point.h"

Déclaration
class point using namespace std ;

Définition
{ int x, y ; point::point (int abs, int ord)
public : { x = abs ; y = ord ; }
point (int a=0, int b=0) ;
void affiche (string x= " ") ; void point::affiche (string message)
}; { cout << message <<" Je suis en : " << x << " " << y << "\n" ;}

point.h point.cpp

Utilisation
#include "point.h"
main()
{ point a ;
a.affiche () ;
point b (5) ;
b.affiche ("Point b - ") ;
point c (3, 12) ;
c.affiche ("Hello ---- ") ;
system("pause");
} main.cpp

Dev C++
La Programmation Orientée Objet: Encapsulation(1/3)

Encapsulation
 Un mécanisme consistant à rassembler les données et les méthodes au sein d'une structure

Le masquage des données

 Assurer l'intégrité des données (Les des données fournies conformes aux attentes)

L'utilisateur ne doit pas accéder (en lecture ou écriture) directement aux attributs d’un objet.
 Il doit utiliser les fonctions définies pour l’accès (appelées interfaces)

 Mettre l'étiquette private sur les données membres.

 Prévoir des fonctions membres public pour manipuler ces données

P1

Ibrahimi ATOS
nom societe
La Programmation Orientée Objet: Encapsulation(2/3)

Visibilité des membres d’une classe

 L'encapsulation permet de définir 3 niveaux de visibilité des éléments de la classe.

 Ces 3 niveaux de visibilité définissent les droits d'accès aux données selon que l'on y accède par:
 Une méthode de la classe elle-même
 Une classe héritée
 Une classe quelconque.

public : (+ en UML) les fonctions de toutes les classes peuvent accéder aux données ou aux
méthodes d'une classe définie avec le niveau de visibilité public.
protected : (# en UML) comme private sauf que l'accès est aussi autorisé aux corps des
méthodes des classes qui héritent (directement ou indirectement) de cette classe.
private : (- en UML) restreint l'accès aux seuls corps des méthodes de cette classe. Il s'agit du
niveau de protection des données le plus élevé.
La Programmation Orientée Objet: Encapsulation(3/3)

Un accesseur est une fonction membre

 Permet de récupérer le contenu d'une donnée membre protégée.

P1

Ibrahimi ATOS
nom societe
Un Modificateur est une fonction membre
 Permet de modifier le contenu d'une donnée membre protégée.
La Programmation Orientée Objet: Encapsulation(Exemple)

#include<iostream>
#include<string>
using namespace std;
class Personne {
int main()
private: {
string nom;
int age;
string societe;
public :
Personne(string nom="inconnu",string societe="Sans",int age=0)
{ this->nom=nom;
this->societe=societe;
this->age=age; }
void SetAge(int a){
if (a < 112) age = a;
else age=0; }
void setnom(string value){ nom=value;}
void setsociete(string value){societe=value;}
string getnom(){ return nom;}
string getsociete(){return societe;}
}
void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille chez " << societe << endl ;
cout << "je suis agé de: " << age<< endl ;
}
};
Dev C++
La Programmation Orientée Objet: Attributs statiques

Constat: Chaque objet possède ses propres membres données

P1 P2

P1.nom Ibrahimi Ibrahimi P2.nom

P1.societe ATOS ATOS P2.societe

Objectif: comment permettre à plusieurs objets de partager des données

A.z B.z C.z

A.x B.x C.x

A.y B.y C.y

Objet A Objet B Objet C

Moyen: Déclarer ses membres données avec le qualificatif static

Une donnée statique:
 Adresse ne change pas
 Attribut de classe
La Programmation Orientée Objet: Attributs statiques

#include<iostream> P1.nbr_pers P1 P2
P2.nbr_pers
#include<string>
P1.nom Ibrahimi Ibrahimi P2.nom
using namespace std;
class Personne { P1.societe ATOS ATOS P2.societe
private:
string nom;
string societe;
public :
static int nb_pers;
~Personne(){
nb_pers--;
}
Personne(){
nom="pers";
societe="??";
nb_pers++; }
Personne(string a, string b){
nom=a; societe=b; nb_pers++; }

void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;
}
};
Dev C++ 2 Dev C++ 1
La Programmation Orientée Objet: Attributs statiques

#include<iostream> int Personne::nb_pers=0; // déclaration obligatoire à l’extérieur de la classe en

#include<string> global et initialisation
using namespace std;
class Personne { Pour éviter l’inclusion multiple, il est conseillé de prévoir l’initialisation des
private: membres données statiques dans le fichier contenant la définition de la classe.
string nom;
string societe; int main()
public : {
static int nb_pers; Personne P1 ("Bennani","CompInfo");
~Personne(){ P1.presenteToi( );
nb_pers--;
} Personne P2 ;
Personne(){ P2.presenteToi( );
nom="pers";
societe="??"; Personne* Ptr_5=new Personne();
nb_pers++; Ptr_5->presenteToi();
}
Personne(string a, string b){ cout << "avant destruction: " << P1.nb_pers << endl;
nom=a; P2.~Personne();
societe=b; cout << "aprés destruction1: " << P1.nb_pers << endl;
nb_pers++; delete Ptr_5;
} cout << "aprés destruction2: " << P1.nb_pers << endl;
void presenteToi( ) {
cout << "je suis " << nom << endl ; system("pause");
cout << "je travaille à " << societe << endl ; }
}
};
Dev C++ 2 Dev C++ 1
La Programmation Orientée Objet: Fonctions statiques

Une Fonction statique est une fonction membre

A un rôle totalement indépendant d’un quelconque objet
Une fonction de classe.
 N’a accès qu’aux membres statiques ( de classe ).
Un objet a accès à ses membres propres et aux membres statiques.
La Programmation Orientée Objet: Fonctions statiques

#include<iostream>
#include<string>
using namespace std;
class Personne {
private:
string nom;
string societe;
static int nb_pers;
public :
~Personne(){
nb_pers--; }

Personne(){
nom="pers"; societe="??"; nb_pers++; }

Personne(string a, string b){

nom=a; societe=b; nb_pers++; }

void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;}

static int linb_pers(){

return nb_pers;
}
};
La Programmation Orientée Objet: Fonctions statiques

#include<iostream> int Personne::nb_pers=0;

#include<string>
using namespace std; int main()
class Personne { {
private:
Personne individu ("Bennani","CompInfo");
string nom; individu.presenteToi( );
string societe; Personne individu1 ;
static int nb_pers; individu1.presenteToi( );
public : cout << "avant destruction: " << individu1.linb_pers() << endl;
~Personne(){ individu.~Personne();
cout << "aprés destruction: " << individu1.linb_pers() << endl;
nb_pers--; }
system("pause");
}
Personne(){
nom="pers"; societe="??"; nb_pers++; }
Personne::linb_pers() // de préférence
Personne(string a, string b){ individu1.linb_pers() // moins naturel
nom=a; societe=b; nb_pers++; }

void presenteToi( ) {
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ;}

static int linb_pers(){

return nb_pers;
}
};
La Programmation Orientée Objet: Fonctions Membres Constantes

Fonctions Constantes: sont des fonctions qui ne modifient pas l’état d’un objet : fonctions de consultation ( ou accesseur).

Objet constant:
 Définition:
o Un objet dont l’état ne doit être changé
o Sur un objet constant on ne peut appeler que des fonctions constantes.
 Analogie: Variable constante
o Le compilateur identifie facilement les fonctions interdites (qui peuvent modifier sa valeur)
Problème:
difficile pour le compilateur d’identifier les fonctions interdites pour un objet constant
 Solution:
o L’utilisateur définit, parmi les fonctions membres, lesquelles sont autorisées à opérer
sur des objets constants en utilisant le mot const dans leur déclaration
La Programmation Orientée Objet: Fonctions Membres Constantes

#include<iostream> #include "point.h"

class point{ #include <iostream>
float x,y; using namespace std ;
public : int point::nbr_point=0;
static int nbr_point; point::point (float abs, float ord)
float abscisse (); { x = abs ; y = ord ; nbr_point++;}
float ordonnee (); point::~point(){
point(float a,float b); nbr_point--; }
~point(); void point::deplace (float dx, float dy)
void deplace(float,float); { x = x + dx ; y = + dy ;}
void affiche() const; void point::affiche ()
}; { cout << "Mes coordonnées sont " << x << " " << y << "\n" ;
cout << "le nombre de point est: " << nbr_point <<endl; }
float point::abscisse(){return x; }
float point::ordonnee(){return y; }
La Programmation Orientée Objet: Fonctions Membres Constantes

Fonction Membre Constante

1- Elle est utilisable pour un objet déclaré constant

point a ; a.affiche () ;// correct

const point c ; c.affiche () ; // correct
a.deplace (...) ; // correct
c.deplace (...) ; // incorrecte rejetée par le compilateur

La même remarque s’appliquerait à un objet reçu en argument :

void f (const point p) // ou même void f(const point & p)
{ p.affiche () ; // OK
p.deplace (...) ; // incorrecte
}

2- Les instructions de sa définition ne doivent pas modifier la valeur des membres de l’objet constant

class point Les membres statiques font exception à cette règle, car ils ne sont pas associés à
{ int x, y ; un objet particulier :
public : class compte
void affiche () const { static int n ;
{ public :
x++ ; // erreur car affiche a été déclarée const void test() const
} { n++ ; // OK bien que test soit déclarée constante, car n est un membre statique
}; }
};
La Programmation Orientée Objet: Fonctions Membres Constantes

Les membres mutables

 Règle: Une fonction membre constante ne peut modifier les valeurs des membres non statiques.

 Exception : les membres mutables accepte la modification

class exemple
{ int x, y ;
mutable int n ; // n est modifiable par une fonction membre constante
void f(.....)
{ x = 5 ; n++ ; }
void f1(.....) const
{ n++ ;
x=5; // erreur : f1 est const et x n’est pas mutable
}
};
La Programmation Orientée Objet: Autoréférence (le mot clé this)

le mot clé : this

 Utilisable uniquement au sein d’une fonction membre, désigne un pointeur sur l’objet
l’ayant appelée.

#include <iostream> main()

using namespace std ; {
class point point a(5), b(3,15) ;
{ a.affiche ();
int x, y ; b.affiche ();
public : }
point (int abs=0, int ord=0)
{ x=abs;
y=ord ; }

void affiche () ;
};

void point::affiche ()
{ cout << "Adresse : " << this << endl;
cout << " - Coordonnees " << x << " " << y << "\n" ;
}
La Programmation Orientée Objet: Objets membres

Supposant qu’une personne a une adresse (Cp, Rue et ville)

La Programmation Orientée Objet: Objets membres

Supposant qu’une personne a une adresse (Cp, Rue et ville)

class Personne { #include<iostream>
private: #include<string>
string nom; using namespace std;
string societe;
Adresse adr;
class Adresse{
public : private:
int CP;
Personne(string a,string b, int x, string y, string z) { string rue;
nom=a; societe=b; adr=Adresse(x,y,z); string ville;
} public :
};
Adresse ( int a=1, string b="rr", string
int main() c="gg"){
{ CP=a;
Personne p1("pop","comp",14000,"medv","kenitra"); rue=b;
system("PAUSE"); ville=c;
cout << " constr.adresse " << CP << " " << rue
} <<"****" <<this <<endl;
}
};
La Programmation Orientée Objet: Objets membres

class Personne {
private:
string nom; #include<iostream>
string societe; #include<string>
Adresse adr; using namespace std;
public : class Adresse{
private:
Personne(string a,string b, Adresse x) { int CP;
nom=a; string rue;
societe=b; string ville;
adr=x; public :
cout << "je suis " << nom << endl ;
cout << "je travaille à " << societe << endl ; Adresse ( int a=1, string b="rr", string c="gg"){
adr.affiche(); CP=a;
} rue=b;
ville=c;
}; cout << " constr.adresse " << CP << " " << rue <<endl;
}
int main() void affiche(){
{ cout << this->CP <<"****"<< this->rue << "***" <<this->ville
Adresse ad(1400,"mdv","rabat"); <<endl;
Personne p1("pop","comp",ad); }
};
system("PAUSE");

}
La Programmation Orientée Objet: Fonction et classe amies

Fonctions et classes amies

Fait: Le principe d’encapsulation interdit à une fonction membre d’une classe d’accéder à
des données privées d’une autre classe.
Objectif: contourner les droits d’accés et les protections d’une classe
Moyen: déclarer qu’une ou plusieurs fonctions (extérieures à la classe) sont des « amies »
Résultat: la fonction ou la classe a acces aux membres privés et protègés de la classe au
même titre que n’importe quelle fonction membre.

Il existe plusieurs situations d’amitiés :

• fonction indépendante, amie d’une classe ;
• fonction membre d’une classe, amie d’une autre classe ;
• fonction amie de plusieurs classes ;
• toutes les fonctions membres d’une classe, amies d’une autre classe.
La Programmation Orientée Objet: Fonction et classe amies

Fonctions et classes amies

Il est possible de contourner les droits d’accés et les protections d’une classe. Pour cela, une classe a le droit de déclarer qu’une
fonction ou une autre classe est une de ses amies. Dans ce cas, la fonction ou la classe a acces aux membres privés et protèges de la
classe.
Attention, l’amitié n’est pas un concept objet. Elle permet simplement de contourner l’encapsulation des données. Il faut
l’utiliser le moins possible.

Syntaxe :
class NomClasse {
...
friend double fonc(...);
friend class AutreClasse;
};
La Programmation Orientée Objet: Fonction et classe amies (exemple)

Exemple ProjetA
Soit la classe point suivante :
class point Point.h
class point { int x, y ;
{ int x, y ; public :
public :
friend void affiche (point &) ;
point (int abs=0, int ord=0)
point (int abs=0, int ord=0)
{ x = abs ; y = ord ;
} { x=abs ; y=ord ;
}; }
};
Écrire une fonction indépendante affiche, amie de la
classe point, permettant d’afficher les coordonnées #include " Point.h"
Indep.cpp
d’un point. #include <iostream>
On fournira séparément : using namespace std ;
1- un fichier source contenant la nouvelle déclaration void affiche (const point & p)
(définition) de point { cout << "Coordonnées : " << p.x << " " << p.y << "\n" ;
2- un fichier source contenant la définition de la }
fonction affiche.
3- un petit programme (main) qui crée un point de
classe automatique et un point de classe dynamique et #include "point.h"
qui en affiche les coordonnées. #include<iostream>

main()
{ point a(1,5) ;
affiche (a) ;
point * adp ;
adp = new point (2, 12) ;
affiche (*adp) ;
system("PAUSE");
}
La Programmation Orientée Objet: Fonction et classe amies (exemple)

Exemple ProjetA
Soit la classe vecteur3d définie dans l’exercice 70 par :
class vecteur3d class vecteur3d Vecteur3d.h
{ float x, y, z ; { float x, y, z ;
public : public :
vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0) friend int coincide (const vecteur3d &, const vecteur3d &) ;
{ x = c1 ; y = c2 ; z = c3 ; } vecteur3d (float c1=0, float c2=0, float c3=0)
..... { x = c1 ; y = c2 ; z = c3 ;
}; }
Écrire une fonction indépendante coincide, amie de la };
classe vecteur3d, permettant de
savoir si deux vecteurs ont les mêmes composantes #include " Vecteur3d.h "
Indep.cpp
(cette fonction remplacera la fonction
membre coincide qu’on demandait d’écrire dans int coincide (const vecteur3d & v1, const vecteur3d & v2)
l’exercice 70). { if ( (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) )
Si v1 et v2 désignent deux vecteurs de type vecteur3d, return 1 ;
comment s’écrit maintenant le test else return 0 ;
de coïncidence de ces deux vecteurs ? }
La Programmation Orientée Objet: Fonction et classe amies (exemple)

Exemple ProjetA
Soit la classe point suivante :
class point Point.h
class point { int x, y ;
{ int x, y ; public :
public :
friend void affiche (point &) ;
point (int abs=0, int ord=0)
point (int abs=0, int ord=0)
{ x = abs ; y = ord ;
} { x=abs ; y=ord ;
}; }
};
Écrire une fonction indépendante affiche, amie de la
classe point, permettant d’afficher les coordonnées #include " Point.h"
Indep.cpp
d’un point. #include <iostream>
On fournira séparément : using namespace std ;
1- un fichier source contenant la nouvelle déclaration void affiche (const point & p)
(définition) de point { cout << "Coordonnées : " << p.x << " " << p.y << "\n" ;
2- un fichier source contenant la définition de la }
fonction affiche.
3- un petit programme (main) qui crée un point de
classe automatique et un point de classe dynamique et #include "point.h"
qui en affiche les coordonnées. #include<iostream>

main()
{ point a(1,5) ;
affiche (a) ;
point * adp ;
adp = new point (2, 12) ;
affiche (*adp) ;
system("PAUSE");
}
La Programmation Orientée Objet: Fonction et classe amies (exemple)

Exemple ProjetA
Soit la classe vecteur3d définie dans l’exercice 70 par :
class vecteur3d class vecteur3d Vecteur3d.h
{ float x, y, z ; { float x, y, z ;
public : public :
vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0) friend int coincide (const vecteur3d &, const vecteur3d &) ;
{ x = c1 ; y = c2 ; z = c3 ; } vecteur3d (float c1=0, float c2=0, float c3=0)
..... { x = c1 ; y = c2 ; z = c3 ;
}; }
Écrire une fonction indépendante coincide, amie de la };
classe vecteur3d, permettant de
savoir si deux vecteurs ont les mêmes composantes #include " Vecteur3d.h "
Indep.cpp
(cette fonction remplacera la fonction
membre coincide qu’on demandait d’écrire dans int coincide (const vecteur3d & v1, const vecteur3d & v2)
l’exercice 70). { if ( (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) )
Si v1 et v2 désignent deux vecteurs de type vecteur3d, return 1 ;
comment s’écrit maintenant le test else return 0 ;
de coïncidence de ces deux vecteurs ? }
La Programmation Orientée Objet: Surcharge d’opérateurs

Il est pratique de pouvoir utiliser les opérateurs classiques pour

effectuer des opérations sur des objets (par ex. des objets mathématiques : somme de vecteurs, produits de matrices, ...).
Le C++ permet de surcharger la plupart des opérateurs du C :
•+ - * / += -= ... ++ --
•== < > <= >= ...
•[] ()
•new delete
•l’affectation =
L’avantage de la surcharge d’opérateurs est de
pouvoir réutiliser les dénominations “naturelles” de ceux-ci.
La Programmation Orientée Objet: Surcharge d’opérateurs

Surdéfinition d’opérateur avec une fonction membre Surdéfinition d’opérateur avec une fonction amie
#include<iostream> class vecteur3d
using namespace std; { float x, y, z ;
class vecteur3d public :
{ float x, y, z ; vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0)
public : { x = c1 ; y = c2 ; z = c3 ;
vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0) }
{ x = c1 ; y = c2 ; z = c3 ;} friend int operator == (vecteur3d, vecteur3d) ;
int operator == (vecteur3d) ; friend int operator != (vecteur3d, vecteur3d) ;
int operator != (vecteur3d) ; };
}; int operator == (vecteur3d v, vecteur3d w)
{ if ( (v.x == w.x) && (v.y == w.y) && (v.z == w.z) ) return
int vecteur3d::operator == (vecteur3d v) 1;
{ if ( (v.x == x) && (v.y == y) && (v.z ==z) ) return 1 ; else return 0 ;
else return 0 ;} }
int vecteur3d::operator != (vecteur3d v) int operator != (vecteur3d v, vecteur3d w)
{ return ! ( (*this) == v ) ;} { return ! ( v == w ) ;
main(){ }
vecteur3d v1(2.3,25,4.6);
vecteur3d v2(2.3,25,4.6);
int m= v1==v2;
cout<< "***** "<< m <<endl;
system("pause");
}
La Programmation Orientée Objet: Surcharge d’opérateurs

Surdéfinition d’opérateur avec une fonction membre Surdéfinition d’opérateur avec une fonction amie
#include <iostream> #include <iostream>
using namespace std ; using namespace std ;
class point class point
{ int x, y ; { int x, y ;
public : public :
point (int abs=0, int ord=0) { x=abs ; y=ord ;} point (int abs=0, int ord=0) { x=abs ; y=ord ;}
point operator + (point) ; friend point operator+ (point, point) ;
void affiche () { cout << "coordonnees : " << x << " " void affiche () { cout << "coordonnees : " << x << " " << y
<< y << "\n" ; } << "\n" ; }
}; };
point point::operator + (point a) point operator + (point a, point b)
{ point p ; { point p ;
p.x = x + a.x ; p.y = y + a.y ; p.x = a.x + b.x ; p.y = a.y + b.y ;
return p ; return p ;
} }

main() main()
{ point a(1,2) ; a.affiche() ; { point a(1,2) ; a.affiche() ;
point b(2,5) ; b.affiche() ; point b(2,5) ; b.affiche() ;
point c ; point c ;
c = a+b ; c.affiche() ; c = a+b ; c.affiche() ;
c = a+b+c ; c.affiche() ; c = a+b+c ; c.affiche() ;
} }
La Programmation Orientée Objet: Surcharge d’opérateurs

Énoncé class vecteur3d

Soit la classe vecteur3d ainsi définie : { float x, y, z ;
class vecteur3d public :
{ float x, y, z ; vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0)
public : { x = c1 ; y = c2 ; z = c3 ;
vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0) }
{ x = c1 ; y = c2 ; z = c3 ; friend vecteur3d operator + (vecteur3d, vecteur3d) ;
} friend float operator * (vecteur3d, vecteur3d) ;
}; };

Définir l’opérateur binaire + pour qu’il fournisse la somme de vecteur3d operator + (vecteur3d v, vecteur3d w)
deux vecteurs, et l’opérateur binaire * pour qu’il fournisse le { vecteur3d res ;
produit scalaire de deux vecteurs. On choisira ici des res.x = v.x + w.x ;
fonctions amies. res.y = v.y + w.y ;
return res ;
}

float operator * (vecteur3d v, vecteur3d w)

{ return (v.x * w.x + v.y * w.y + v.z * w.z) ;
}
Programmation Orientée Objet
3- Héritage Simple
La Programmation Orientée Objet: Héritage Simple

L’héritage (ou spécialisation, ou dérivation) permet d’ajouter des

propriétés à une classe existante pour en obtenir une nouvelle
plus précise.
A partir d’une classe A, on définit une nouvelle classe dérivée B
A est la classe de base
B est la classe dérivée de A.
La classe dérivée B
•hérite de tous les membres de A (données ou fonctions)
•peut ajouter de nouveaux membres (données ou fonctions)
•peut redéfinir des membres existants dans A (données ou fonctions).
L’héritage permet :
•la réutilisation du code déjà écrit
•l’ajout de nouvelles fonctionnalités
•la modification d’un comportement existant (redéfinition)
Remarque : la suppression de membres en utilisation l’héritage privé (private).

L'héritage entre classes symbolise les relations hiérarchiques entre les

concepts. Si une classe B hérite d'une classe A, on dit A est la
classe mère et B la classe fille, on dit aussi que B dérive de A ou encore
que B est dérivée de A. La relation d'héritage est une relation de
généralisation-spécialisation : B est une spécialisation de A et A est
unegénéralisation de B.

Tout écriture de programme en C++ doit être précédée d'une phase de

modélisation du problème dans laquelle on définit les concepts que l'on
manipule et leurs relations. Dans cette phase de modélisation, on utilise
généralement la représentation UML

Par dérivation la classe dérivée récupère tous les membres de la classe de base
sauf les constructeurs, le destructeur et l’opérateur
La Programmation Orientée Objet: Héritage Simple
La Programmation Orientée Objet: Héritage Simple

Notion de redéfinition
Il ne faut pas mélanger la redéfinition et la surdéfinition :
•Une surdéfinition ou surcharge (overloading) permet d’utiliser plusieurs méthodes
qui portent le même nom au sein d’une même classe avec une signature différente.
•Une redéfinition (overriding) permet de fournir une nouvelle définition d’une
méthode d’une classe ascendante pour la remplacer. Elle doit avoir une signature
rigoureusement identique à la méthode parente.
Un objet garde toujours la capacité de pouvoir redéfinir une méthode afin
de la réécrire ou de la compléter.
La Programmation Orientée Objet: Héritage Simple

Appel de constructeurs
La Programmation Orientée Objet: Héritage Simple

Propriétés de la généralisation
La Programmation Orientée Objet: Héritage Simple

spécificateur d'accès :
Public : les membres publics de la classe sont accessibles dans la classe et à l'extérieur de la classe.
Private : les membres privés d'un objet ne sont accessibles qu'à l'intérieur de la classe par les objets de la classe (
les fonctions membres de la classe ).
Nouveau statut : protected.
Private et Protected :
•A l'extérieur de la classe : private et protected sont équivalents, les membres sont toujours inaccessibles.
•Seul un objet de la classe a accès aux membres privés et protégés (données ou fonctions) de sa classe.
la différence est visible uniquement dans les opérations de dérivation.
•Une zone privée d'une classe devient toujours inaccessible (plus fort que privé) dans une classe dérivée, quelque soit la
dérivation publique, protégée ou privée.
•Une zone protégée reste accessible (protégée) dans une classe dérivée publiquement.
La Programmation Orientée Objet: Héritage Simple

Les types de Dérivation

class A {
Statut des membres de base private : int x;
protected : int y;
public protected private
public : int z ;
Mode Public public protected inaccessible void fa( );
de Protected protected protected inaccessible };
dérivation Private private private inaccessible

Dérivation publique (la plus courante) class B : public A {

public : void fb( );
Les membres privés de la classe de base deviennent inaccessibles dans la classe dérivée, les };
autres membres de la classe de base conservent leur statut dans la classe dérivée. void A :: fa ( ) {
x = 1;
y = 1;
z = 1;
}
void B :: fb () {
x = 1; // interdit
y = 1;
z = 1;
Inaccessible Inaccessible
}

privé privé
int main() {
A a;
B b;
protégé protégé a.x = 1; // interdit
a.y = 1; // interdit
a.z = 1;
a.fa( ) ;
publique publique b.x = 1; // interdit
b.y = 1; // interdit
b.z = 1;
b.fa( ) ;
Classe de base C. dérivée par héritage publique b.fb( ) ;
}
La Programmation Orientée Objet: Héritage Simple

class A {
Les types de Dérivation Statut des membres de base private : int x;
protected : int y;
public protected private
public : int z ;
Mode Public public protected inaccessible void fa( );
de Protected protected protected inaccessible };
dérivation Private private private inaccessible

Dérivation privée class B : private A {

public : void fb( );
Les membres privés de la classe de base deviennent inaccessibles dans la classe dérivée, };
les autres membres de la classe de base deviennent privés dans la classe dérivée. void A :: fa ( ) {
x = 1;
y = 1;
z = 1;
}
void B :: fb () {
x = 1; // interdit
y = 1;
z = 1;
Inaccessible Inaccessible
}

privé privé
int main() {
A a;
B b;
protégé protégé
a.x = 1; // interdit
a.y = 1; // interdit
a.z = 1;
publique publique a.fa( ) ;
b.x = 1; // interdit
b.y = 1; // interdit
b.z = 1; // interdit
Classe de base C. dérivée par héritage publique b.fa( ) ; // interdit
b.fb( ) ;
}
La Programmation Orientée Objet: Héritage Simple

class A {
Les types de Dérivation Statut des membres de base private : int x;
protected : int y;
public protected private
public : int z ;
Mode Public public protected inaccessible void fa( );
de Protected protected protected inaccessible };
dérivation Private private private inaccessible

Dérivation privée class B : protected A {

public : void fb( );
Les membres privés de la classe de base deviennent inaccessibles dans la classe dérivée, les };
autres membres de la classe de base deviennent protégés dans la classe dérivée void A :: fa ( ) {
x = 1;
y = 1;
z = 1;
}
void B :: fb () {
x = 1; // interdit
y = 1;
Inaccessible Inaccessible z = 1;
}

privé privé
int main() {
A a;
protégé protégé B b;
a.x = 1; // interdit
a.y = 1; // interdit
a.z = 1;
publique publique a.fa( ) ;
b.x = 1; // interdit
b.y = 1; // interdit
Classe de base C. dérivée par héritage publique
b.z = 1; // interdit
b.fa( ) ; // interdit
b.fb( ) ;
}