1 Les concepts de base de la POO Application en C++ Les concepts

Transcription

Les concepts de base de la POO
La notion d'objets
Application en C++
Intuitivement, un objet est une représentation d'une
entité du monde réel.

Encapsulation
Héritage
Polymorphisme
une voiture, une maison, une personne, …
Un objet est caractérisé par un ensemble de propriétés

une voiture possède une marque, un modèle, un numéro
d'immatriculation, …
une maison a une adresse, un style, …
une personne est connue par son nom, son prénom, sa date
de naissance, …
Les objets peuvent avoir des liens entre eux :

une personne possède une voiture, une maison, …
2
1
La notion d'objets
La notion d'objets

On peut parler d'objets particuliers :

PERSONNE

mais tous ces objets ont les mêmes caractéristiques

On peut donc aussi parler d'ensemble d'objets.

possède
une marque, un modèle, …
habite

VOITURE
voiture : une Fiat Tipo, une Renault Mégane, …
MAISON

classe voiture

un objet particulier

Notion d'objets, relations entre les objets, ensemble d'objets,….
Î description d'une classe d'objets : classe voiture
Î description d'un objet particulier : une instance de la classe

marque, modèle, numéro d'immatriculation, …
marque = Fiat, modèle=Tipo, numéro=5678FV21
3
4
La notion d'objets

La notion d'objets
Des objets peuvent avoir des propriétés
communes et des propriétés spécifiques.
VEHICULE
Par exemple, tous les véhicules possèdent une
marque, un modèle, un numéro, …

CAMION
les camions ont en plus une charge maximale,
les véhicules d'entreprise font partie d'une société,
une ambulance possède un équipement,
etc …

5
VEHICULE
D'ENTREPRISE
AMBULANCE
Hiérarchie de généralisation/spécialisation
6
1
La notion d'objets

La description des objets et de leurs caractéristiques
s'accompagne de la description des opérations
applicables sur ces objets.

Encapsulation :

description d'une classe d'objets, de ses propriétés et des opérations sur
ces objets dans un même ensemble
définition de droits d'accès sur les objets ou les opérations sur les objets

opérations pour connaître les propriétés de l'objet
opérations pour mettre à jour ces propriétés
opérations pour manipuler les objets
Héritage :

possibilité de définir de nouveaux objets par spécialisation d'objets
existants
hiérarchies de généralisation/spécialisation
Réutilisation

Par exemple, pour une voiture, on peut vouloir

connaître sa marque, son modèle, …
changer son numéro d'immatriculation, …
dessiner cette voiture sur un écran ou une imprimante, …
Polymorphisme

mécanisme sophistiqué qui permet de gérer les opérations sur les objets
d'une hiérarchie

7
8
Encapsulation

Encapsulation
On veut construire un objet «complexe »
constitué de deux éléments : r et i
(respect. partie réelle et partie imaginaire)
et d'opérations pour le manipuler.

Définition d'une classe
class complexe
{private :
int r, i; // description des champs
public :
// description des méthodes
int lire_r(void);
int lire_i(void);
void ecrire(int, int);
};
initialiser : affecte les champs d'un complexe
lire_r : retourne la valeur de la partie réelle
lire_i : retourne la valeur de la partie
imaginaire
9
10
Encapsulation

int complexe :: lire_r(void)
{ return(r);

Les droits d'accès sur les membres d'une classe peuvent être :

private

}
void complexe :: ecrire(int vr, int vi)
{r=vr;

}
int complexe :: lire_i(void)
{return(i);

Encapsulation

i=vi; }
protected

par défaut les droits sont fixés à la valeur "private"
sur l'exemple, les droits sur les membres de la
classe (r et i) sont privés
11

Les membres placés en mode privé ne sont accessibles qu'aux membres
de la classe elle-même.
Les membres placés en mode protégé sont accessibles aux membres de
la structure elle même et aux membres des classes descendantes (dans
une chaîne d'héritage).
public

Les membres placés en mode public sont accessibles par tout membre
situé dans la portée de la classe (en général dans tout le texte source).
12
2
Encapsulation

void main (void )
{ complexe c1, c2 ;
int vr, vi;
c1.ecrire ( 0 , 0 );
Déclaration des objets d'une classe

Encapsulation
nom_classe nom_objet;
Cette déclaration rend disponible un objet pour lequel sont
accessibles tous les membres déclarés "public" dans la définition
de la classe.
cout << "partie réelle ?"; cin >> vr;
cout << "partie imaginaire ?"; cin >> vi;
c2.ecrire( vr , vi );
Pour désigner un membre d'un objet on utilise la notation

nom_objet . nom_membre
Pour les membres champs, cette notation permet un accès aux
champs de la structure.
Pour les membres méthodes, cette notation permet d'exécuter la
méthode (c'est un appel de fonction).
}
cout << "vérification :\n";
cout << "1" << c1.lire_r () << " + i * " << c1.lire_i () ;
cout << "2" << c2.lire_r () << " + i * " << c2.lire_i () ;
13
14
Encapsulation

Encapsulation
Remarques

Le programme principal ne peut pas accéder
directement aux champs r et i d'un objet de la classe
complexe.

Méthodes amies

Idée intuitive : possibilité de donner des droits spéciaux

Ses membres ont été déclarés comme privés, donc
interdits en accès à toute fonction non membre de la
classe.

nécessité de “nommer” cette méthode comme ayant des
droits spéciaux dans la classe concernée

C’est une méthode :

de manipulation des champs privés ou protégés d'une classe
à une méthode “externe” à la classe.
L'usage des fonctions lire_r, lire_i et ecrire est
obligatoire.

concept de méthode amie d’une classe
qui n'est pas membre de la classe
mais qui a le droit de manipuler les membres privés et protégés
de la classe
La déclaration se fait par le mot-clé "friend"
15
Encapsulation

16
Encapsulation
class matrice
{ int mat[MAX][MAX];
public :
void affiche(void);
void saisie(void);
..........................
friend vecteur mult_mat_vect(matrice, vecteur);
};
class vecteur
{ int vect[MAX];
public :
void affiche(void);
void saisie(void);
..........................
friend vecteur mult_mat_vect(matrice, vecteur);
};
Soit “matrice” une classe qui modélise une matrice
carrée d’entiers, et certaines opérations sur les matrices
(saisie, affichage, produit,...)
Soit “vecteur” une classe similaire sur les vecteurs
On souhaite définir le produit d’une “matrice” par un
“vecteur” de façon externe à ces deux classes mais en
manipulant directement les champs privés de ces
classes.
17
18
3
Encapsulation

Encapsulation
Définition de la fonction de multiplication

Autre possibilité de définition d’une méthode amie
Une méthode amie d’une classe peut être membre d’une autre classe.

vecteur mult_mat_vect(matrice m, vecteur v)
{ ............
}

La fonction “mult_mat_vect” est déclarée amie des deux classes
“vecteur” et “matrice”
pas d'opérateur de résolution de portée car non membre de la
classe
peut accéder aux membres privés des deux classes
Sur l’exemple ci-dessus, on peut associer la fonction mult_mat_vect à
la classe “matrice” et la déclarer comme amie de la classe “vecteur”.

class matrice
{ int mat[MAX][MAX];
public :
void affiche(void);
void saisie(void);
vecteur mult_mat_vect(vecteur v);
..........
};
Appel de la fonction
vecteur v1,v2;
matrice mt;
..........
v2= mult_mat_vect(mt,v1);
19
20
Encapsulation
Encapsulation
class vecteur
{ int vect[MAX];
public :
void affiche(void);
void saisie(void);
..........................
friend vecteur matrice :: mult_mat_vect(matrice
m, vecteur v);
};

Définition de la méthode de multiplication
vecteur matrice :: mult_mat_vect(vecteur v)
{ ............
}
Appel de la méthode
vecteur v1,v2;
matrice mt;
..........
v2= mt.mult_vect_mat(v1);
21
22
Encapsulation

Surcharge des méthodes et des opérateurs
Lorsque toute les fonctions d’une classe sont des amies d’une autre
classe, on peut déclarer globalement la classe comme étant amie de
la première.
On souhaite par exemple que toutes les méthodes de la classe
“matrice” soient amies de la classe “vecteur”, on peut écrire :
Les méthodes d'une classe peuvent être
surchargées

Surcharge la méthode "ecrire" de la classe
complexe selon un deuxième profil :
class vecteur
{ ........
friend class matrice;
.........
};
La définition de fonctions "amies" peut remettre en cause les
mécanismes de protection liés à l'encapsulation des données

void ecrire(void)

qui affecte les parties réelles et imaginaires à 0.
utiles pour surcharger les opérateurs prédéfinis
23
24
4
void complexe :: ecrire(int vr, int vi)
{ r=vr; i=vi; }
class complexe
{private :
// description des champs
int r, i;
public :
// description des méthodes membres
int lire_r(void);
int lire_i(void);
void ecrire(void)
};
void complexe :: ecrire(void)
{ r=0; i=0; }

Remarque : dans ce cas particulier, le
mécanisme de valeur par défaut des paramètres
pourrait être utilisé.
void complexe :: ecrire(int r=0, int i=0);
25

La surcharge des opérateurs peut être réalisée à l’aide :

De méthodes membres de la classe,
de méthodes indépendantes et amies de la classe.

La 2 ème solution remet en cause l’encapsulation « stricte » des
données de la classe.

Lorsque la surcharge est faite à l’aide d’une méthode indépendante,
le nombre d’arguments doit être celui de l’opérateur de base.

Pour une méthode membre, le premier argument est toujours
l’instance courante de la classe.

26
Si l’opérateur est unaire, la méthode membre n’aura donc pas
d’argument.
Et si l’opérateur est binaire, l’argument est le membre droit de
l’opérateur.
class complexe
{private :
// description des champs
int r, i;
public :
int lire_r(void);
int lire_i(void);
void ecrire(void)
complexe operator+ (complexe);
complexe operator- (complexe);
};
27
28
Surcharge de l'opérateur +
complexe complexe :: operator+ (complexe c)
{ complexe cpl;
cpl.r = r + c.r;
cpl.i = i + c.i;
return(cpl);
}

29
Utilisation de l'opérateur surchargé
void main (void)
{ complexe c1, c2, c3;
c1.initialiser(4,4);
c2.initialiser(5,5);
c3 = c1 + c2; // c3 = c1.operator+(c2);
cout << c3.lire_r() << c3.lire_i() ;
}

30
5
Initialisation des objets d'une classe

void main (void)
{ complexe c1,c2;
/* appel explicite de la méthode ecrire */
c1.ecrire(5,8);
c2.ecrire();
}
possibilité d'omission de l'appel de la fonction
idée pour plus de sécurité :
De façon classique, l'initialisation d'un objet peut être faite par
un appel explicite à une méthode d'écriture
class complexe
{private :
int r, i;
public :
// description des méthodess membres
void ecrire(void)
...
};

appel implicite à une méthode d'initialisation à la
déclaration d'un objet de la classe
31
32

C++ propose une solution simple et élégante
pour répondre à ce problème

possibilité de décrire une (ou des) méthode(s)

de même nom que la classe
et considérée comme des méthodes d'initialisation
associées à chaque déclaration d'un objet

Les constructeurs

De façon similaire, il est possible de définir un
destructeur,

Définition de la classe complexe avec un constructeur
class complexe
{private :
int r, i;
public :
// description d’un constructeur avec 2 arguments
complexe (int, int);
...
};
méthode dont le nom est ~nom_classe,
appelée lorsqu'une variable est détruite.
33
34
complexe :: complexe (int vr, int vi)
{ r=vr;
i=vi; }

C++ permet de définir plusieurs constructeurs dont les profils sont
différents (par leur nombre de paramètres)

pas d'ambiguïté pour le compilateur
class complexe
{private :
int r, i;
public :
complexe(int);
...
};
Déclaration d'objets avec le constructeur
void main(void)
{ complexe c1(4,7);
complexe c2 = complexe (4,7);
…
}
complexe :: complexe (int vr)
{
r=vr; i=0;}
35
36
6

C++ distingue plusieurs types de constructeurs. L’un d’eux est le
constructeur par défaut i.e. c’est un constructeur sans paramètre
class complexe
{private :
int r, i;
public :
complexe(void);
complexe(int);
...
};
complexe :: complexe (void)
{
r=0; i=0; }

// constructeur par défaut
37
Il est conseillé de définir systématiquement un
constructeur par défaut.
Un constructeur dont tous les arguments ont une
valeur par défaut peut être assimilé à un
constructeur par défaut
complexe (int vr=0, int vi=0);
38

Le constructeur par copie

Son rôle est de créer une copie d’une instance existante d’un objet :

traitement réalisé par défaut : recopie bit à bit d’une zone de mémoire vers une
autre
en général suffisant, sauf lorsque de l’allocation dynamique doit être réalisée pour
construire l’objet cible
Le constructeur par copie est appelé à chaque fois qu’il est nécessaire de
recopier une instance :

lors d’une déclaration d’une instance si l’initialisation est faite à l’aide de la valeur
d’une autre
Lors du passage par valeur d’une instance à une fonction
lors du renvoi d’une instance par une fonction
l’utilisation de l’affectation ne provoque pas l’appel du constructeur par copie
39
7