Cours 3

Cours de programmation orientée objet

(C++)

Pr. SAID EL ABDELLAOUI

Elabdellaoui.said@yahoo.fr

Ecole supérieure de technologie de Safi

S. El Abdellaoui
Mohamed
El Nabil
Abdellaoui SaïdSaidi 2015/ 2016
Classe, Objet

2
 Classe, Objet (exemple)
 Une classe est la description d'une famille d'objets ayant même structure
(données) et même comportement (méthodes).

 Exemple de Classe « Point » :

Point
 Les données x et y sont dites privées. Ceci Private: x
signifie que l’on ne peut les manipuler qu’au y
travers des fonctions membres (l’encapsulation
des données). Initialiser()
Deplacer()
Afficher()
 a et b sont des objets de classe «point», c’est-
à-dire des variables de type «point». On parle
aussi d ’instances.

a b

x =? x =?
y=? y=?

Mohamed
El Nabil
Abdellaoui SaïdSaidi 3
 Classe, Objet (Déclaration)
 En C++ une classe se déclare par le mot-clé class.

 Exemple :
class Rectangle {
...
};

 Ceci définit un nouveau type du langage.

 La déclaration d’une instance d’une classe se fait de façon similaire

à la déclaration d’une variable :
rect1
nom_classe nom_instance ;
h =?
Exemple : l =?

Rectangle rect1; //déclare une instance rect1 de la classe Rectangle.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 4
 La vie d’un Objet
création

initialisation

observation modification

libération

destruction

Mohamed
El Nabil
Abdellaoui SaïdSaidi 5
 Création, initialisation et affectation des objets
 Création :
• C++ fournit un constructeur par défaut.
• Ce constructeur permet la création de nouveaux class Rectangle{
objets. …..
};
• On pourra définir ses propres constructeurs.

 Initialisation : Int main()

{
• l ’initialisation doit être prévue par le constructeur
Rectangle rect1;
de la classe.
return 0;
}
 Affectation :
• Par défaut, l ’affectation de 2 objets de même type
correspond à une simple recopie des valeurs des
données membres à membres
• Les objets comportant une partie d ’allocation
dynamique n ’obtiendront qu’une simple recopie des
pointeurs sur les zones dynamiques.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 6
 Déclaration des attributs et méthodes
 Attributs:
• La syntaxe de la déclaration des attributs est : #include <iostream>
Using namespace std;
type nom_attribut ;
class Rectangle{
• L’accès aux valeurs des attributs d’une instance double hauteur;
de nom nom_instance se fait comme pour accéder double largeur;
aux champs d’une structure : };

nom_instance.nom_attribut Int main()

{
Rectangle rect1;
• Exemple : la valeur de l’attribut hauteur d’une rect1.hauteur=3.0;
instance rect1 de la classe Rectangle sera rect1.largeur=4.0;
référencée par l’expression : cout<<"hauteur : <<rect1.hauteur
<<endl;
rect1.hauteur return 0;
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 7
 Déclaration des attributs et méthodes
 Méthodes:
• La syntaxe de définition des méthodes est :
Type_retour nom (type_par1 nom_par1, ...)
{
... // corps de la méthode
}
• La déclaration des méthodes suie deux façon :
 Interne : La déclaration des méthodes est à l’intérieure de la classe.
 Externe : Pour relier la définition d’une méthode à la classe pour
laquelle elle est définie, il suffit d’utiliser l’opérateur :: de résolution de
portée :
 La déclaration de la classe contient les prototypes des méthodes

 les définitions correspondantes spécifiées à l’extérieur de la

déclaration de la classe se font sous la forme :

TypeRetour NomClasse :: nomFonction(type1 par1, type2 par2 , ...)

{ ... }

Mohamed
El Nabil
Abdellaoui SaïdSaidi 8
 Déclaration et appels des méthodes

 Déclaration : class Rectangle{

double hauteur;
double largeur;
double surface(); // prototype
};
// définition
double Rectangle :: surface()
{
return hauteur×largeur;
}

 Appel :

rect1.surface() : méthode surface de la classe Rectangle s’appliquant à rect1

rect1.surface() ~ Rectangle::surface(&rect1)

Mohamed
El Nabil
Abdellaoui SaïdSaidi 9
 Déclaration des attributs et méthodes
 Actions et Prédicats :
• En C++, on peut distinguer les méthodes qui modifient l’état de l’objet (« actions »)
de celles qui ne changent rien à l’objet (« prédicats »). On peut pour cela ajouter le
mot const après la liste des paramètres de la méthode :

type_retour nom_methode (type_par1 nom_par1, ...) const

class Rectangle{
double hauteur;
double largeur;
double surface() const ; // prototype
};
// définition
double Rectangle :: surface() const
{
return hauteur×largeur;
}
• Si vous déclarez une action en tant que prédicat (const), vous aurez à la compilation
le message d’erreur :
assignment of data-member ‘...’ in read-only structure
Mohamed
El Nabil
Abdellaoui SaïdSaidi 10
 Contrôle d'accès
- Attributs de protection des membres d'une classe : En C++, on peut contrôler
l'accès aux membres des structures class et aussi struct, en leur donnant un attribut
public, private, protected .

 Public :
 Les membres public sont accessibles par tout le
programme. Les membres public définissent l’interface de
class TXX{
la classe (ne mettre que des méthodes en public).
public:

int Calculer(int);
 Protected : void Afficher();
 Les membres placés après ce mot réservé peuvent être
atteints par les fonctions membres déclarées (ou définies) };
dans la même structure ou classe et par les classes dérivées
de cette classe (notion de famille : cf héritage).

Mohamed
El Nabil
Abdellaoui SaïdSaidi 11
 Contrôle d'accès
 Private :
 Les membres privés ne sont accessibles que par les méthodes membres (ou
friend , notion vue plus tard).

class TXX{

private :

int numéro

};

 Tous les attributs sont privés ?

Et si on a besoin de les utiliser depuis l’extérieur de la classe ?!
 Par exemple, comment « manipuler » la largeur et la hauteur
d’un rectangle .

Mohamed
El Nabil
Abdellaoui SaïdSaidi 12
 Accesseurs et manipulateurs
- Si le programmeur le juge utile, il inclut les méthodes publiques nécessaires ...

 Accesseurs (« méthodes get » ou « getters ») :

 Consultation (i.e. « prédicat »)
Retour de la valeur d’une variable d’instance précise.

double getHauteur() const {return hauteur; }

double getLargeur() const {return largeur; }

 Manipulateurs (« méthodes set » ou « setters ») :

 Modification (i.e. « action »)

Affectation de l’argument à une variable d’instance précise

void setHauteur (double h) {hauteur=h; }

void setLargeur (double l) {largeur=l; }

Mohamed
El Nabil
Abdellaoui SaïdSaidi 13
 Exemple Complet (1/3)
#include <iostream>
 Déclaration Interne : using namespace std;

// définition de la classe
class Rectangle{

// Attributs
Private :
double hauteur;
double largeur;

// Méthodes
Public :
double surface() const
double getHauteur() const
double getLargeur() const
double setHauteur (double h)
double setLargeur(double l)
{return hauteur×largeur; }
{return hauteur; }
{return Largeur; }
{hauteur = h; }
{largeur = l; }

};
Mohamed
El Nabil
Abdellaoui SaïdSaidi 14
 Exemple Complet (2/3)
#include <iostream>
 Déclaration Externe : using namespace std;
// définition de la classe
class Rectangle{
// Attributs
Private :
double hauteur;
double largeur;
// Prototypes
Public :
double surface() const ;
double getHauteur() const ;
double setHauteur (double h); //idem pour les autres
};
// Méthodes
Public :
double Rectangle:surface() const {return hauteur×largeur; }
double Rectangle:getHauteur() const {return hauteur; }
double Rectangle:setHauteur (double h) {hauteur = h; }
//idem pour les autres
Mohamed
El Nabil
Abdellaoui SaïdSaidi 15
 Exemple Complet (3/3)
// Utilisation de la Classe
 Main(): int main() {

Rectangle rect;
double lu;

cout<<"Quelle hauteur ? ";

cin>>lu;
rect.setHauteur(lu);

cout<<"Quelle largeur ? ";

cin>>lu;
rect.setLargeur(lu);

cout<<"surface = "<< rect.surface() <<endl;

return 0;

Mohamed
El Nabil
Abdellaoui SaïdSaidi 16
 Implémentation de la classe

 Fichier Header.h : placer dans un « .h » la définition et l’implémentation

des méthodes de la classe.

 Fichier Source.cpp : utilisation de la classe en incluant le fichier « .h »

Mohamed
El Nabil
Abdellaoui SaïdSaidi 17
 Auto-référence : le pointeur this
 Si, dans une méthode, un attribut est masqué alors la valeur de l’attribut peut
quand même être référencée à l’aide du mot réservé this.

 this est un pointeur sur l’instance courante

this ~ "mon adresse"
 Syntaxe pour spécifier un attribut en cas d’ambiguïté :
this->nom_attribut
Exemple :
class point {
int x,y
public :
void initialise(int , int);
};
void point :: initialise(int x, int y)
{this->x=x; this->y=y}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 18
Constructeur,
Destructeur

19
 Notion de constructeur
 Un constructeur est une fonction membre qui permet de dégager l ’utilisateur des
taches d ’allocation/initialisation.

 Propriétés d ’un constructeur :

• porte toujours le même nom que la classe
• ne renvoie pas de valeur de retour (même pas un void)
• garantit que l ’objet sera toujours initialisé.

 Syntaxe :

NomClasse(liste_parametres) NomClasse(liste_parametres) :
{ liste des initialisations des
//initialisation des paramètres parametres {}
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 20
 Notion de constructeur

 Une classe avec un constructeurs.

class point
{ int x,y;
public: point() {x = 20; y = 10;}
void deplace(int dx , int dy) {x = x+dx; y = y+dy;}
void affiche() {gotoxy(x,y);cout<<"Je suis en "<<x<<" "<<y<<"\n";}
};
void main()
{ point a,b; // les deux points sont initialisés en 20,10
a.affiche(); a.deplace(17,10); a.affiche();
getch() ;}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 21
 Notion de constructeur
 Une classe peut avoir plusieurs constructeurs.
class point
{ int x,y;
public:
point() {x = 20; y = 10;} //constructeur 1
point( int abs, int ord) {x = abs; y = ord;} //constructeur 2
void deplace( int dx , int dy) {x = x+dx; y = y+dy;}
void affiche() {cout<<"Je suis en "<<x<<" "<<y<<"\n";}
};
void main()
{
point a,b; // constructeur 1 :les deux points sont initialisés en 20,10,
point c(15,30); // constructeur 2 :c sera initialisé en 15, 30
point d(11, 21); //constructeur 2 :d sera initialisé en 11, 21
a.affiche(); a.deplace(17,10); a.affiche();
b.affiche(); b.deplace(5,5); b.affiche();
c.affiche(); c.deplace(51,5); c.affiche();
d.affiche(); d.deplace(5,10); d.affiche();
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 22
 La vie d’un Objet
création

initialisation

observation modification

libération

destruction

Mohamed
El Nabil
Abdellaoui SaïdSaidi 23
 Notion de destructeur
 Le destructeur est une fonction membre systématiquement exécutée «à la fin de
la vie » d’un objet statique, automatique, ou dynamique. On ne peut pas passer de
paramètres par le destructeur.

 Propriétés d ’un destructeur :

• porte le même nom que la classe
• est précédé par ~

class vecteur
{ int taille,*v;
public:
//constructeur
vecteur( int n) {if (n>0) {taille = n; v=new int[n];}}
//destructeur
~ vecteur() {cout<<’ ’appel au destructeur ’ ’}};
void main()
{ vecteur Vect;
getch() ;}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 24
 Notion de destructeur

class point
{int x, y;
public :
point( int a ,int b ) //constructeur
{cout <<"constructeur de l'objet("<<a<<","<<b<<")...\n";x=a;y=b;}
void deplacer( int dx, int dy) {x=x+dx; y=y+dy;}
void afficher(){gotoxy (x,y);cout<<"je suiss en "<<x<<" "<<y<<"\n";}
~point() {cout<<"destructeur de l ’objet("<<this->x<<","<<this->y<<")\n";}
};

void main()
{ point a(5,5),b(10,10);
a.afficher(); b.afficher();
getch();
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 25
 Notion de destructeur
 Création d ’un objet dynamiquement par new

class point
{int x, y;
public :
point( int a ,int b ) //constructeur
{cout <<"constructeur de l'objet("<<a<<","<<b<<")...\n";x=a;y=b;}
void deplacer( int dx, int dy) {x=x+dx; y=y+dy;}
void afficher(){gotoxy (x,y);cout<<"je suiss en "<<x<<" "<<y<<"\n";}
~point() {cout<<"destructeur de l ’objet("<<this->x<<","<<this->y<<")\n";}
};

void main()
{ point *p;
p=new point(10,4);
p->afficher();
getch();
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 26
 Constructeur par défaut
 Constructeur par défaut : est un constructeur sans arguments ou dont chacun des
arguments possède une valeur par défaut. Il est utilisé lorsque l ’on crée des
tableaux d ’objets.
class Toto
{ int n;
 Exemple :
public: Toto( int i); //constructeur}
};
void main()
{ Toto tableau[3]; //Erreur : il faut un constructeur par défaut
getch() ;}

class Toto
{ int n;
public: Toto( int i=30); //constructeur par défaut}
};
void main()
{ Toto tableau[3]; //Correct : tous les objets initialisés à 30
getch() ;}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 27
 Constructeur par défaut par défaut
 Si aucun constructeur n’est spécifié, le compilateur génère
automatiquement une version minimale du constructeur par défaut qui :

 appelle le constructeur par défaut des attributs objets.

 laisse non initialisés les attributs de type de base.

 Dès qu’au moins un constructeur a été spécifié, ce constructeur par défaut

par défaut n’est plus fourni.

 Si donc on spécifie un constructeur sans spécifier de constructeur par

défaut, on ne peut plus construire d’objet de cette classe sans les initialiser (ce
qui est voulu !) puisqu’il n’y a plus de constructeur par défaut.

 On peut le rajouter si on veut :

NomClasse()= default;

Mohamed
El Nabil
Abdellaoui SaïdSaidi 28
 Constructeur par copie
 Constructeur par recopie : est spécialisé dans la création d ’un objet à partir d ’un autre
objet pris comme modèle.

5
a *

class vect
{int taille; // nbre elts
5
double * adr; // ptr sur ces elts b *
public :
vect(int n ) //constructeur
{adr=new double[taille=n];
cout << "Const. Usuel -adr objet "<<this<<" -adr vecteur " <<adr<< "\n" ;}
~vect() {cout<< " Dest. -adr objet" <<this<<" -adr -vecteur <<adr<< "\n";
};

void main()
{ vect a(5);
vect b=a;}
Mohamed
El Nabil
Abdellaoui SaïdSaidi 29
 Constructeur par copie
 La syntaxe du constructeur par recopie T::T(T&)

class vect
{int taille; double * adr;
public : vect(int n ) //constructeur
{adr=new double[taille=n];
cout << "Const. Usuel -adr objet "<<this<<" -adr vecteur " <<adr<< "\n" ;}
vect(vect &v) //constructeur par recopie
{adr
adr=new
=new double[taille=v.taille
double[taille=v.taille];
];
for(int
for( int i=0; i<taille;i
i<taille;i++)
++) adr
adr[i]=v.adr[i]
[i]=v.adr[i]
cout << "Const
Const.. Par recopie -adr objet "<<
"<<this
this<<"
<<" -adr vecteur " <<
<<adr
adr<<
<< "\n ’’ ;}
~vect() {cout<< " Dest. -adr objet" <<this<<" -adr -vecteur <<adr<< "\n"; } ;

void main()
{ vect a(5); a 5
vect b=a;} *

5
b *

Mohamed
El Nabil
Abdellaoui SaïdSaidi 30
 Spécificateur static

 Donnée membre : le spécificateur static permet de définir des membres communs à

plusieurs instances d’une classe

 Fonction membre : le spécificateur static permet de définir une fonction “normale”

qui n'est utilisable que par les instances de la classe où elle a été définie.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 31