Conception & programmation

orienté objet C++

1
Les objectifs de la POO
Les objectifs ayant induit le développement de la programmation objet sont
essentiellement :
 D’accroître la productivité des logiciels
 D’augmenter leur fiabilité
Pour atteindre ces deux objectifs, deux critères essentiels ont permis d’arriver à
l’approche Orientée Objet (A.O.O.) :
 L’extensibilité :
la possibilité d’étendre un logiciel lors d’un changement de spécification
sans trop modifier l’existant
 La ré-utilisabilité
La possibilité de réutiliser des composants logiciels déjà existant dans de
nouvelles applications.

!!! Dans la vie d’un projet informatique, il semble que 60% à 80% des erreurs
soient des erreurs de conception ou de spécification

2
Diverses approches de conception

Trois approches de conception :

 L’approche fonctionnelle
 L’approche par Systémique
 L’approche par objets

3
MÉTHODES DE CONCEPTION

On distingue principalement de trois approches de conception :

 Méthodes fonctionnelles

 Méthodes systémiques

 Méthodes orientées objets

4
 Méthodes fonctionnelles
 Les méthodes fonctionnelles consistent à décomposer hiérarchiquement une
application en un ensemble de sous applications.
 Ces méthodes utilisent les raffinements successifs pour produire des
spécifications taille sur les besoin
Points forts
 Simplicité du processus de conception 2
 Capacité à répondre rapidement aux besoins ponctuels des utilisateurs
Points faibles
 Fixer les limites pour les décompositions hiérarchiques
 Redondance (éventuelle) des données

5
 Méthodes systémiques
 Les méthodes systémiques sont influencées par les systèmes de Gestion de bases de
données en proposant une double démarche de modélisation :
 La modélisation des données
 La modélisation des traitements
Points forts
 Approche globale prenant en compte la modélisation des données et des
traitements
 Niveaux d’abstraction dans le processus de conception
 Bonne adaptation à la modélisation des données et à la conception des BDs
Points faibles
 Double démarche de conception : données et traitements
 Pas de fusion possible des deux aspects (données et traitements)

6
 MÉTHODES FONCTIONNELLES ET SYSTÉMIQUES

 Les méthodes fonctionnelles et systémiques sont de type descendant

(approache TopDown). Inconvénients
 Réutilisabilité :
 Modules non généraux mais taillé aux sous problèmes pour lesquels
ils ont été conçus ;
 Extensibilité :
 L’architecture du logiciel est fondée sur les traitements qui sont
moins stables que les données ; par conséquent cette approche est
inadaptée à la conception de gros logiciel.

7
 Méthodes fonctionnelles
 Les méthodes fonctionnelles consistent à décomposer hiérarchiquement une
application en un ensemble de sous applications.
 Ces méthodes utilisent les raffinements successifs pour produire des
spécifications taille sur les besoin
Points forts
 Simplicité du processus de conception 2
 Capacité à répondre rapidement aux besoins ponctuels des utilisateurs
Points faibles
 Fixer les limites pour les décompositions hiérarchiques
 Redondance (éventuelle) des données

8
 Méthodes systémiques
 Les méthodes systémiques sont influencées par les systèmes de Gestion de bases de
données en proposant une double démarche de modélisation :
 La modélisation des données
 La modélisation des traitements
Points forts
 Approche globale prenant en compte la modélisation des données et des
traitements
 Niveaux d’abstraction dans le processus de conception
 Bonne adaptation à la modélisation des données et à la conception des BDs
Points faibles
 Double démarche de conception : données et traitements
 Pas de fusion possible des deux aspects (données et traitements)

9
 MÉTHODES FONCTIONNELLES ET SYSTÉMIQUES

 Les méthodes fonctionnelles et systémiques sont de type descendant

(approache TopDown). Inconvénients
 Réutilisabilité :
 Modules non généraux mais taillé aux sous problèmes pour lesquels
ils ont été conçus ;
 Extensibilité :
 L’architecture du logiciel est fondée sur les traitements qui sont
moins stables que les données ; par conséquent cette approche est
inadaptée à la conception de gros logiciel.

10
 MÉTHODES ORIENTÉES OBJETS

 Dans une approche Orientée Objet (OO), le logiciel est

considéré comme une collection d’objets dissociés défini
par des propriétés.
 Une propriété est soit un attribut de l’objet ou une
opération sur l’objet.
 Un objet comprend donc à la fois une structure de données
et une collection d’opérations (son comportement).
 Contrairement aux méthodes fonctionnelles et systémiques,
les méthodes orientées objets sont ascendantes

11
 Classe-Objet

 Une classe est un modèle de la structure statique (les champs ou attributs) et du comportement
dynamique (les opérations ou méthodes) des objets (instances) associés à cette classe;
 La classe décrit le domaine de définition d'objets. Chaque objet appartient à une classe. Les
généralités sont contenues dans la classe alors que les particularités dans les objets. Les objets
informatiques sont construits à partir de la classe par un processus appelé instanciation. De ce
fait tout objet est une instance de classe.

12
 Une classe est définie par les attributs et les opérations (méthodes).

 Attributs : Appelés également champs correspondent aux propriétés de la classe. Ils sont définis
par un nom, un type de données et éventuellement une valeur initiale. Un attribut est une variable
qui stocke des données.
Exemple : considérons la classe Employé caractérisée par les attributs code, nom et nbEmployés (nombre d'employés)

 Les attributs code et nom sont des caractéristiques de chaque objet Employé contrairement au
champ nbEmployés qui est une caractéristique commune à tous les objets. On dira que
nbEmployés est attribut statique.
statique

 Chaque objet, instance d'une classe, donne des valeurs particulières à tous les attributs définis
dans sa classe sauf les attributs statiques ce qui détermine son état.

 Exemples :

13
 L’héritage
L’héritage simple
Principe
Le but est de construire de nouvelles classes à partir de classes déjà
existantes ; C’est le mécanisme fondamental de la réutilisabilité.
Terminologie :
Classe de base
La classe dérivée se différencie de la classe de base :
Par enrichissement, c’est-à-dire par ajout de données et de méthodes
Par substitution, c’est-à-dire par redéfinition de fonctions membres
héritées de la classe de base.
Classe dérivée

Syntaxe :
Class < classe-dérivée> : {public, private, protected} <classe-de-
base>

14
l’héritage peut être :
 Public
 Private
 Protected
 Sans attribut( nous dirons << normal>>)

15
 Divers niveaux de protection des informations
les membres d’une classe peuvent être :
 Soit private
private, auquel cas ils ne sont accessibles qu’aux membres de
la classe ;
 Soit public
public, et là ils sont accessibles aux membres de la classe et
aux classes clientes.
 En C++, une classe dérivée n’a pas accès aux membres privés de la
classe de base.
 Dans la pratique, la classe dérivée doit presque toujours avoir
accès aux attributs en capsulés de la classe de base.
 C++ a créé un niveau de protection intermédiaire, le niveau
protected : les membres protected sont inaccessibles aux classes
clientes, mais accessible aux membres de la classe et aux classes
dérivées.

16
Figure9
17
Figure9
18
Figure9
19
Figure9
20
Récapitulation
Quelque soit l’héritage :
 Une classe dérivée a accès aux membres public et protected de la
classe de base.
 Une classe cliente d’une classe dérivée a accès aux membres public de
cette dernière.
En général, sauf pour l’héritage private ou protected
 Si B dérivée de A, et si C dérive de B, la classe C a accès aux membres
publics et protected de A (transitivité).

21
 Particularités de l’héritage private
class B : private A{ } ;
class C: B{ };
La classe B a accès aux membres public et protected de
A. Mais ils deviennent private pour B, ce qui signifie
que C mais ne pourra pas y’accéder.

22
 Particularités de l’héritage Protected

class B : protected A {};

class C: B{};
La classe B a accaccèès aux membres public et protected de A. Mais ils
deviennent protected pour B, ce qui signifie que C pourra en en
hériter, et que les classes clientes de B ne pourront en aucun cas y
avoir acc
accèès.
La classe C aura acc
accèès aux membres public et protected de B, et aussi à
ceux de A qui sont devenus protected dans B.

23
 Particularités de l’héritage public
 Une classe cliente de la classe dérivée à accès aux membres
publics de la classe dérivée ainsi qu’aux membres publics de la
classe de base.
Figure9

 C’est l’héritage le plus employé, car correspondant le mieux à la

notion d’héritage de la C.O.O.. Il est naturel de pouvoir
manipuler dans une classe cliente, les membres publics de la
classe de base.

 La différence entre l’héritage sans attribut et l’héritage public est

que les classes clientes des classes dérivées n’ont pas accès aux
membres public de la classe de base.

24
Constructeur et destructeur dans la classe
dérivée
 Une classe dérivée peut avoir ses constructeurs.
 Quand la classe de base et la classe dérivée ont leurs
constructeurs, le constructeur de la classe de base est
appelé en premier, puis le constructeur de la classe
dérivée.
 Il est possible d’appeler explicitement le constructeur de
la classe de base dans la définition du constructeur de la
classe dérivée ( juste après l’en-tête suivi de :).

25
Exemple :
#include <iostream.h>
class point
{ protected :
int abscisse;
int ordonnée;
public :
point(int=0,int=0);
void affiche();
void deplacer(int);
};
classe pointForme : public point
{ private :
char forme;
public:
pointFome(int=0, int=0, char='*');
void deformer(char);
void afficher();
};
partie interface doit être mise dans le fichier d’entête point..h

26
 La partie implémentation de la classe dérivée sera :

#include " point.h "
#include"pointforme.h"
#include <iostream.h>

pointForme::PointForme(int x, int y, char f):point(x,y)

{forme= f;}
void pointForme:: afficher()
{Point ::affiche() ;
cout << " forme : " <<forme << " \n " ;}
void pointForme::deformer(char nf)
{forme=nf;}
Implémentation doit être enregistrer dans le fichier pointForme.cpp

27
le destructeur
 Pour le destructeur l'ordre d'appel est
inverse: c'est le destructeur de la classe
dérivée qui est appelé en premier, puis
le destructeur de la classe de base.

28
L’héritage multiple

En C++, une classe peut hériter de plusieurs classes de base.

Déclaration
 La déclaration est analogue à celle de l’héritage simple, mais il
y’a plusieurs classe de base séparée par les virgules
 syntaxe A B
Class C : public A, public B
{
…
C
…};
 Les modalités d’accès aux membres des classes de base
répondent aux même règles que pour l’héritage simple ;
 L’ordre des classes de base n’a pas d’influence sur le parcours
du graphe d’héritage ;

29
 Structure des instances de la classe dérivée :
Les champs des instances de la classe dérivée sont constitués
de l’union des champs propres à la classe dérivée et des
champs des classes de bases. Même chose, en ce qui
concerne les méthodes
 On peut être amené à utiliser l’opérateur de
résolution de portée ::, si :
un membre m d’une des classes de base est redéfini dans la
classe dérivée Deux classes de base ont un membre m de
même nom

30
Class pointForme : public point, public Forme
{ public :
pointForme(int=0, int=0, char=’*’) ;
void affiche() ;
}
l’implémentation de la classe dérivée pourra être :
#include "point.h"
#include "forme.h"
#include "pointforme.h"

pointforme::pointforme(int x, int y, char f): point(x,y), forme(f)

{}
void pointforme::afficher()
{ point::affiche();
forme::affiche();}

31
 Problèmes liés à l’héritage multiple

 Lorsqu’on crée une instance de D, le constructeur de

A est appelé deux fois, une fois par le biais du
constructeur de B et une fois par le biais du
constructeur de C. Les membres hérités de A sont
alors dupliqués dans les instances de D.

B C

32
 Pour éviter la duplication des champs, il faut utiliser
des clases virtuelles. Les classes de base dont on veut
éviter la duplication doivent être déclarées virtuelles.
Class B : public virtual A{…};
Class C:public virtual A{….};
Class D:public B,public C{…};

A B m
m A B m

m C C

33
 Constructeur
 La création d’un objet de la classe dérivée provoque l’appel du constructeur de chacune
des classes de base dans l’ordre des déclarations.
Considérons les spécifications suivantes:
class point
{ protected :
int abscisse;
int ordonnee;
public:
point (int =0, int=0);
void affiche();
void deplcer(int);
};
class forme
{protected :
char forme;
public :
forme( char='*');
void affiche');
void deformer(char);
};

34
 Les méthodes virtuelles
sous-typage
 La dérivation correspond à une opération de sous-typage.
 Un objet de la classe dérivée peut être affecté à un objet de la classe de
base. Mais l’inverse n’est pas possible sans une conversion de type
explicite
 Exemple :
Class point {…} ;
Class PointForme : public Point{…} ;
….
Point p ;
PointForme q ;
…
p=q ; //affectation légale
q=p ; //illégal

35
 L’affectation p=q provoque une conversion
automatique de type.
 Le fonctionnement est analogue pour les
pointeurs : un pointeur sur une classe dérivée
sera implicitement converti en un pointeur vers
la classe de base.
Point *pP ;
PointForme *pPf ;
PP=pPf ;//legal

36
Typage statique
 Le type des objets est défini au moment de la
compilation.
 Dans le cas d’une redéfinition de méthode, c’est
toujours la méthode de la classe de base qui va
être appelée, même s’il y’a conversion implicite
de type dans la classe de base.

37
 Méthode f() publique
A

Méthode f() publique

Méthode f() publique

C

38
Aa;
Bb;
C c;
A *p;
P=&a;
p->f();// c’est f() de A qui est appelée : Normal!!

 P=&b ; // conversion implicite du pointeur de classe dérivée en

pointeur de classe de base
 p->f() ;// c’est f() de A qui s’applique sur un objet de classe B.
 p=&c ; // conversion implicite
 p->f() ; // c’est f() de A qui s’applique sur un objet de classe C
 Le choix de la méthode est fait statiquement par le compilateur en
fonction du type des objets. Mais il serait intéressant de pouvoir
appliquer la méthode correspondant réellement au type de l’objet,
malgré la conversion de type. Les méthodes virtuelles vont le permettre.

39
Méthodes virtuelles et typage dynamique
 Dans l’exemple précédent, si les méthodes f() sont déclarées virtuelle
dans la classe de base A, c’est toujours la bonne méthode qui
s’appliquera en fonction du type réel des objets.
 Une redéfinition de la méthode virtuelle dans une classe dérivée est
implicitement virtuelle (l’attribut virtual n’est plus nécessaire). Pour
déclarer une virtuelle il suffit de placer l’attribut virtual en tête de son
type prototype :
Class A
{…
public :
virtual void f();
…
};
 Quand la méthode f() est appelée, le compilateur ne décide pas quelle
est celle qui va être appelée. Le choix sera fait au moment de
l’exécution : c’est qu’on appelle la ligature dynamique ou typage
dynamique.

40
 Classes abstraites et méthodes virtuelles pures
 Une méthode virtuelle pure est une méthode dont la
définition est nulle.
….
….
Virtual void f()=0 ;
….
 Une méthode virtuelle pure d’une classe de base doit
obligatoirement être redéfinie dans les clases dérivées.
 Une classe abstraite est une classe contenant au moins
une fonction virtuelle pure.
 Une classe abstraite ne peut être instanciée.

41
 Exemple 1  class chien: public Animal
 Class Animal  { public :
 { public :  void crier();};
 class Oiseau: public Animal
 virtual void crier()=0 ;
 {public :
 };
 void crier();
 class chat:public Animal  };
 {public : void crier();
 };

42
void chat:: crier()
{cout <<”\n miaou ! miaou!\n”;}

void chien:: crier()

{cout << « \n ouah ! ouah !\n » ;}
void Oiseau :: crier()
{ cout << »\n cui ! cui ! \n » ;}

void main()
{Animal * pa[3] ;
pa[0]=new Chat ;
pa[1]=new Chien;
pa[2]=new Oiseau;
for(int I=0; I<3;I++) pa[I]->crier ();}

nous aurons à l’écran :

miou !miou
ouah !ouah !
cui !cui !
L’intérêt est de pouvoir créer des tableaux ou des liste d’objets de types différent,
dynamiquement, et d’appliquer les méthodes propres à chaque élément
dynamiquement.
43
Exemple 2
 Supposons que dans le cadre d’un certain traitement,
nous soyons amenés à manipuler trois classes, Point,
Vecteur et Matrice :
 Point pour gérer des points à 2 coordonnées réelles
 Vecteur, pour gérer des vecteurs à 3 composantes réelles
 Matrice, pour gérer des matrices 3x3 réelles

44
 Supposons que nous désirons écrire un
programme client utilisant un tableau
mélangeant les trois types d’objets.
 Plus particulièrement, nous voulons afficher
les éléments d’un tableau initialisé lors de
l’exécution. Pour chaque élément, il faudra
utiliser la méthode afficher() de sa classe,
dynamiquement.
 Pour cela, nous allons créer une classe
abstraite dont vont dériver Point, Vecteur et
Matrice.

45
 Classe abstraite

Matrice

Point Vecteur

46