Programmation Objet en C++ - olazo.free.frolazo.free.fr/IUT/Cours/cours c++ objet.pdf · IUT A Informatique ~ POO en C++ ~ Chapitre 1 UC LB 26 ObjetObjet Un objet est une entité

~ A. P. ~~ A. P. ~

IUT A Lyon 1IUT A Lyon 1

InformatiqueInformatique

UUCCLLBB

Programmation Objet en C++Programmation Objet en C++Programmation Objet en C++

UUCCLLBB

e présent document constitue le support visuel du cours deprogrammation C++. L'auteur n'autorise pas son utilisation ousa diffusion en dehors du Département Informatique de l'IUT-Ade l'Université Lyon-I.

Merci de signaler les erreurs ou fautes constatées.

~ A. P. ~Chapitre 1~ POO en C++ ~~ POO en C++ ~IUT A InformatiqueInformatique

UUCCLLBB

1

Chapitre I

Présentation du paradigmeobjet

Présentation du paradigmePrésentation du paradigmeobjetobjet


UUCCLLBB

2

Origine des concepts objetOrigine des concepts objetOrigine des concepts objet


UUCCLLBB

3

IntroductionIntroductionIntroduction

� Le développement d'applications informatiques =� des méthodes de conception� des techniques de programmation

� Les méthodes de conception ont historiquementobéi à plusieurs paradigmes� l'approche fonctionnelle� l'approche conceptuelle


UUCCLLBB

4

L'approche fonctionnelleL'approche fonctionnelleL'approche fonctionnelle� Dans cette approche

� l'analyse du monde réel étudié met en évidence lesgrandes fonctions de l'entreprise

� elles mêmes découpées en tâches puis en sous-tâches

� Conséquences:� la vision du système est celle d'un processeur de

traitement avec ses données en entrée,et sesdonnées en sortie

� la démarche est descendante


UUCCLLBB

5

L'approche fonctionnelleL'approche fonctionnelleL'approche fonctionnelle� Le S.I.

� produit de manière automatique des données degestion

� exécute de manière automatique des processus degestion

� au plus bas niveau des fonctions

Fonction de transformationFonction de

transformationDonnées en

EntréeDonnées en

Sortie


UUCCLLBB

6

L'approche fonctionnelleL'approche fonctionnelleL'approche fonctionnelle

� Principes de la conception descendante

� raffinements successifs

� par décomposition en partant du plus haut niveau

� vision hiérarchique du système à travers unedémarche logique


UUCCLLBB

7


FaFa

FbFb FcFc

Fb1Fb1 Fb2Fb2 Fb3Fb3 Fc1Fc1 Fc4Fc4Fc3Fc3Fc2Fc2

Démarche descendante dansl'approche fonctionnelle


UUCCLLBB

8


� Les limites

� séparation données-traitement

� privilégie le rôle des fonctions par rapport auxstructures de données

�ne favorise pas la réutilisabilité

� concepts flous ou insuffisants

� évaluation du résultat difficile


UUCCLLBB

9

L'approche conceptuelleL'approche conceptuelleL'approche conceptuelle

� Dans cette approche� l'entreprise est un système vu comme un ensemble

de sous-systèmes qui interagissent� le SI est un des sous-systèmes

�il est modélisé à partir des besoins identifiés del ’entreprise

�grâce à un travail d'abstraction�et selon une méthode

�modèle�démarche� formalisme


UUCCLLBB

10


Schéma conceptuel

Comprendre lesbesoins , les

inventorier, lesclasser et lesstructurer

Univers d ’application

Base de Données

Modèle

utilise

Analyse

modélise

Source: Corine Cauvet


UUCCLLBB

11


� La démarche de conception

� La modélisation des données�importance des données en tant qu’invariants�indépendance vis à vis du niveau logique (le modèle

de données) et du niveau physique (le modèled'implémentation)

� La modélisation des traitements�traduit la dynamique du système�approche par décomposition fonctionnelle


UUCCLLBB

12


� Les limites

�modélisation des données séparée de lamodélisation des traitements

�mise en adéquation des modèles laborieuse

� décomposition fonctionnelle descendante

� l’ingénierie des besoins est sous-estimée


UUCCLLBB

13

BilanBilanBilan

� Ces approches présentent toutes les deux deslimites

� un style fonctionnel de programmation pour lestraitements

� une dichotomie état-comportement liée à laséparation données-traitement


UUCCLLBB

14

RéponseRéponseRéponse

� Le paradigme objet

� né des réflexions menées sur la programmation

� s'affranchir des limites du style fonctionnel

� remettre en cause la séparation données-traitement


UUCCLLBB

15

Les limites du style fonctionnelLes limites du style fonctionnelLes limites du style fonctionnel

� Conception par raffinements successifs utiliséedans la démarche descendante

� pour obtenir des fonctions ou procédures

� qui manipulent les données

� assemblées afin de constituer un programme


UUCCLLBB

16

Les limites du style fonctionnelLes limites du style fonctionnelLes limites du style fonctionnel

� MAIS...

� programmation dirigée par les traitements

� couplage par les données

� évolutivité difficile car le comportement desfonctions�est souvent lié au contexte d'utilisation�dépend du type des structures de données

manipulées


UUCCLLBB

17

Une première tentativeUne première tentativeUne première tentative� Une approche alternative: le T.A.D.

� T.A.D. = modèle permettant de représenter uneabstraction de l'information�par la connaissance de ses propriétés�par la connaissance de son comportement

� un T.A.D. est défini par�des données représentant ses propriétés�des opérations sur les données

� l'accès aux données du T.A.D. ne se fait que sous lecontrôle des opérations


UUCCLLBB

18

La technique d'encapsulationLa technique La technique d'encapsulationd'encapsulation

� L'utilisateur d'un T.A.D.� ne peut invoquer que les opérations� ignore l'implémentation physique du T.A.D.

� T.A.D. 2 parties:� l'interface: précise les données et les opérations

permettant d'accéder à ces données� la réalisation: comprend la définition des opérations

publiques et des opérations privées� Encapsulation = technique qui consiste à cacher à

l'utilisateur la réalisation du T.A.D. qu'il manipule


UUCCLLBB

19

Type Abstrait de DonnéesType Abstrait de DonnéesType Abstrait de Données

� Traduction en langage C� interface : fichier d'en-tête .h� réalisation : fichier source .c compilé en module

objet ou archivé en bibliothèque� Intérêt de l'approche T.A.D.:

� concevoir des composants réutilisables� augmenter la fiabilité du logiciel� permettre une meilleure maintenance� réduire les coûts et temps de programmation


UUCCLLBB

20

L'objet enfin !L'objet enfin !L'objet enfin !� La notion d'objet est issue de la programmation

� C'est la généralisation de l'approche T.A.D. avecdes mécanismes enrichis� héritage� polymorphisme� template� etc...


UUCCLLBB

21

Programmation ObjetProgrammation ObjetProgrammation Objet

� Style de programmation dans lequel� les données (attributs) et les traitements

(méthodes) sont étroitement associés pour formerun objet�les attributs et les méthodes ne sont pas directement

visibles de l'extérieur�la communication entre l'objet et le monde extérieur

ne peut se faire que par l'interface� un programme est composé d'objets qui

interagissent


UUCCLLBB

22

Objectifs recherchésObjectifs recherchésObjectifs recherchés

� Réutilisation, extension

� Qualité, sécurité, robustesse

� Lisibilité et facilité de maintenance

� Gain de productivité

� Brique de base de la structuration du logiciel


UUCCLLBB

23

Un concept unificateurUn concept unificateurUn concept unificateur� Le développement orienté objet

� s'appuie désormais�sur des méthodes de conception (O.M.T. & U.M.L., etc)�sur des outils de conception (MEGA, TRAMIS…)�sur des langages orienté objet (C++, Java, VB...)

� dans des architectures distribuées

continuité sémantique del'analyse à la programmation


UUCCLLBB

24

B - Présentation des concepts objetB - Présentation des concepts objetB - Présentation des concepts objet


UUCCLLBB

25

Terminologie objetTerminologie objetTerminologie objet

�Objet�Encapsulation�Classe� Instanciation�Message� Interface�Persistance� Identificateur et identifiant�Héritage, association, agrégation


UUCCLLBB

26

ObjetObjetObjet� Un objet est une entité conceptuelle qui traduit une

abstraction du monde réel ou un concept

� Un objet regroupe les données qui le décrivent ETles traitements qui agissent sur ces données

� Un objet répond à des demandes de service émisessous forme de messages

Plus de séparation donnés-traitement

Communication avec l'extérieur


UUCCLLBB

27

ObjetObjetObjet

� Caractéristiques fondamentales

� l'état: tout objet est à un instant donné dans uncertain état décrit par ses attributs (ou donnéesmembres)

� le comportement: déterminé par des méthodes (oufonctions membres) qui modifient l'état de l'objet

� l'identité: propriété propre à l'objet et qui lecaractérise de façon unique


UUCCLLBB

28

interface réalisation

méthodes données

O B J E T

monde

extérieur

messages


UUCCLLBB

29

EncapsulationEncapsulationEncapsulation� Principe

� qui consiste à cacher au monde extérieurl'implémentation interne de l'objet car l'utilisateurd'un objet n'a pas à la connaître

� les attributs et les méthodes sont encapsulés dansl'objet

� l'objet n'est accessible de l'extérieur qu'au traversdes services de l'interface

Séparation entre le mondeintérieur et le monde extérieur


UUCCLLBB

30

EncapsulationEncapsulationEncapsulation� Implique des niveaux de protection

� les attributs sont privés�l'utilisateur ne peut pas manipuler les données ou

les structures de données directement�ce qui garantit une stabilité de l'objet

� les méthodes internes sont privées�elles ne doivent pas être visibles de l'extérieur�parce que sans intérêt pour l'utilisateur de l'objet


UUCCLLBB

31

EncapsulationEncapsulationEncapsulation� Les niveaux de protection (suite)

� les méthodes de l'interface sont publiques

�l'utilisateur n'a accès qu'aux méthodes de l'interface

�elles sont les seules à pouvoir accéder aux donnéesou bien à pouvoir invoquer les méthodes internes

l'interface représente le guichetd'accès aux services de l'objet


UUCCLLBB

32

ClasseClasseClasse� Une Classe est la description d'une famille d'objets

qui ont� la même sémantique� les mêmes attributs� les mêmes méthodes donc le même comportement

� Il s'agit d'une abstraction qui permet de représenterune partie du monde réel

� Lorsque la classe représente quelque chosed'abstrait on parle de réification

� ATTENTION: par abus de langage le terme objet estsouvent utilisé à la place de classe


UUCCLLBB

33

InstanciationInstanciationInstanciation� Une Classe permet de définir un moule pour créer

des objets� Le fait de générer un objet à partir d'une classe

s'appelle l'instanciation� Ce mécanisme fait appel à un constructeur� Tout objet est donc l'instance d'une et d'une seule

classe� On peut dire que la classe est à la programmation

objet ce qu'est le type à la programmationprocédurale


UUCCLLBB

34

MessagesMessagesMessages� L'interaction entre objets se fait par l'envoi de

messages

� soit entre instances (objets) d'une même classe

� soit entre instances (objets) de classes distinctes

� On parle aussi de couplage ou encore decommunication


UUCCLLBB

35

MessagesMessagesMessages� Un message permet d'invoquer un des services

fournis par un objet

� le service doit être disponible à l'interface de l'objet,c'est à dire implémenté par une méthode publique

� la réception du message provoque alors l'exécutionde la méthode appropriée


UUCCLLBB

36

InterfaceInterfaceInterface

� Représente l'ensemble des méthodes publiquesqu'un utilisateur de la classe peut invoquer

� Ces méthodes ne peuvent être invoquées qu'àtravers l'envoi de messages à la classe

� L'interface d'une classe représente donc unprotocole de communication pour les objets de laclasse avec le monde extérieur


UUCCLLBB

37

PersistancePersistancePersistance

� Notion qui caractérise la capacité d'un objet àconserver son état dans le temps et dans l'espace

� Implique d'être capable de sauvegarder et derestaurer l'état et la classe d'appartenance del'objet

� Mise en œuvre� pas de support de la part des langages de

programmation� bases de données objet ou couche objet sur une

base de données relationnelle


UUCCLLBB

38

Identificateur d'objetIdentificateur d'objetIdentificateur d'objet� Identificateur d'un objet (O.I.D. = Object IDentifier)

� permet d'identifier de façon unique tout objet créé

� caractéristiques fondamentales: unicité etrémanence

� nécessaire pour assurer la persistance géréeautomatiquement par le système d'objets de façontransparente


UUCCLLBB

39

Identifiant d'objetIdentifiant d'objetIdentifiant d'objet� Identifiant d'un objet

� il s'agit ici de la notion d'identifiant au sens S.I.

� la pertinence d'un identifiant relève des besoins duS.I.

� il existe de nombreux objets ne nécessitant pas unidentifiant (exemple d'un objet technique comme unconteneur)


UUCCLLBB

40

Identifiant d'objetIdentifiant d'objetIdentifiant d'objet� MAIS il faut souvent

� pouvoir discriminer les objets d'une même classe(exemple des clients)

� dans ce cas on retrouve les caractéristiquesclassiques d'un identifiant�unique et non vide�défini à partir d'un ou plusieurs attributs de l'objet�les autres données de l'objet en D.F. élémentaire et

directe


UUCCLLBB

41

Relation entre classesRelation entre classesRelation entre classes

� Dans l'approche objet le S.I. est vu comme unecollection d’objets qui coopèrent� pour assurer les fonctionnalités attendues il existe

donc�des liens entre les objets�des relations entre les classes

� tous les objets n'ont pas le même niveaud'abstraction�objet technique�objet de gestion


UUCCLLBB

42

Les liens entre objetsLes liens entre objetsLes liens entre objets

� Le lien d’héritage: permet d’ordonner les objetsau sein de hiérarchies de classes en exprimantune relation de type "est une sorte de "

� L’association: exprime une connexionsémantique entre les objets

� L’agrégation: exprime une relation de type"composé-composant"


UUCCLLBB

43

Classification des objetsClassification des objetsClassification des objets� Objets techniques

� objets de servitude nécessaires pour réaliser unesolution informatique

� objets primitifs:�objets qui permettent de traduire des types de base�exemples : Rationnel, Complexe, Cercle, Rectangle…

� objets d'implémentation:�objets qui implémentent des outils plus élaborés�exemples: liste, arbre, fenêtres, bouton,..


UUCCLLBB

44

Classification des objetsClassification des objetsClassification des objets� Objets d'application

� objets dont la pertinence est liée au systèmed'information

� dont le niveau d'abstraction nécessite la mise enœuvre d'une méthode de conception

� objets de servitude conceptuels: objetsspécifiques au domaine de l'application: grille desaisie, paramétrage,..

� objets métier: objets conceptuels réutilisablesdans différentes application d'un même métier:client, compte bancaire,..


UUCCLLBB

45

Classification des objetsClassification des objetsClassification des objets� Comment trouver les objets ?

� objets techniques�beaucoup de classes prédéfinies�construction par déduction�mécanismes utilisés: les modèles et l'héritage

� objets d'application�domaine souvent complexe et vaste�d'où recours à une méthode de conception�mécanismes utilisés: association, agrégation,

composition, héritage, etc..


UUCCLLBB

46

Chapitre II

Programmation objet en C++Programmation objet en C++Programmation objet en C++


UUCCLLBB

47

Éléments du langageÉléments du langageÉléments du langage


UUCCLLBB

48

� Les nouveaux mots clés du langage C++

bool catch classconst_cast delete dynamic_castexplicit export falsefriend inline mutablenamespace new operatorprivate protected publicreinterpret_class static_class templatethis throw truetry typeid typenameusing virtual wchar_t

� Certains mots ont déjà été vus en C++ procédural

Mots réservésMots réservésMots réservés


UUCCLLBB

49

� Le type class est une extension du type struct dulangage C

� La définition d'une classe en C++ comprend� la définition des membres de la classe

�données membres�fonctions membres (méthodes)

� la spécification des droits d'accès aux membres quipermet de préciser�la partie privée de la classe�la partie publique de la classe

Le type classLe type Le type classclass


UUCCLLBB

50

Le type classLe type Le type classclass

� Syntaxe C ++class NomClasse {

private:type donnée_membre;...

public:type fonc_membre(type param);

type fonc_membre(type param) {...;}...

private:type fonc_membre(type param);...

} ;


UUCCLLBB

51

Niveaux d'accèsNiveaux d'accèsNiveaux d'accès

� Les niveaux d'accès aux membres déterminentleur visibilité� public: accessibilité permise depuis l'extérieur de

la classe� protected: accessibilité restreinte à la classe et à

ses classes dérivées� private: accessibilité réduite à la classe

� Seul le concepteur peut accéder à la partie privéede la classe (niveaux private et protected)

� L'utilisateur d'une classe ne peut accéder qu'à lapartie publique (niveau public)


UUCCLLBB

52

Niveaux d'accèsNiveaux d'accèsNiveaux d'accès

� Les données membres d'une classe sont privéesgénéralement d'après le principe d'encapsulation

� Les fonctions membres d'une classe peuvent être� publiques: ce sont des méthodes accessibles

depuis l'extérieur par un utilisateur de la classe etqui représentent les services offerts par la classe

� privées: ce sont des méthodes que le concepteurveut rendre non visibles depuis l'extérieur de laclasse afin d ’en cacher les détails d'implémentation


UUCCLLBB

53

Niveaux d'accèsNiveaux d'accèsNiveaux d'accès� ATTENTION: en C++ les protections sont définies

� au niveau de la classe� et non au niveau de l'objet

� Par conséquent :� toutes les méthodes (privées et publiques) d'un

objet ont bien sûr accès aux données de cet objet�MAIS toutes les méthodes d'un objet peuvent aussi

atteindre directement les données membres d'unautre objet de la même classe


UUCCLLBB

54

Fonctions membresFonctions membresFonctions membres� Prototypées dans le type class

� Définies en dehors de la classe� syntaxe

TypeRetourne NomClasse::NomMéthode(paramètres){.. ..}

� l'opérateur :: est appelé résolution de portée


UUCCLLBB

55

Fonctions membresFonctions membresFonctions membres� Cas particulier des petites fonctions

� très souvent en ligne pour des raisons de lisibilité� deux possibilités:

�la définition de la fonction est directement dans letype class et elle est donc considérée en ligne

�la définition de la fonction est en dehors du typeclass mais on utilise le spécificateur inline

�RAPPEL: le code d' une fonction en ligne estincorporé par le compilateur à chaque appel�alourdit le code�mais accélère l'exécution�donc à ne réserver qu'aux petites fonctions


UUCCLLBB

56

Organisation d'une classe en C++Organisation d'une classe en C++Organisation d'une classe en C++

� Deux fichiers pour définir une classe� l'interface qui comprend le type class

�fichier d'extension .h�définition des attributs (données membres)�prototypes des méthodes (fonctions membres) et/ou

définition des fonctions membres en ligne�niveaux d'accès pour les éléments de la classe

� la réalisation qui comprend le code�fichier d'extension .cc (ou .cpp ou .C)�définition de l'ensemble des méthodes privées ou

publiques de la classe


UUCCLLBB

57

ObjetObjetObjet

� Notion d'objet� un objet est l'instance d'une classe� il est créé par un constructeur� il est détruit par le destructeur� son état est caractérisé par les valeurs de ses

données membres� son comportement est défini par ses méthodes� un objet peut être alloué statiquement (à la

compilation) ou dynamiquement (à l'exécution)


UUCCLLBB

58

ConstructeurConstructeurConstructeur

� Toute création d'objet fait appel à un constructeur� Propriétés des constructeurs

� on peut définir plusieurs constructeurs pour unemême classe grâce à la surcharge

� un constructeur peut être défini avec ou sansparamètres

� un constructeur défini sans argument est appeléconstructeur par défaut

� si il n'y a aucun constructeur défini dans la classe,tout se passe comme si un constructeur par défautétait synthétisé


UUCCLLBB

59


� Propriétés des constructeurs (suite)� si un ou plusieurs constructeurs sont définis dans

la classe, il n'y a pas de constructeur par défautsynthétisé

� on a donc intérêt à toujours définir un constructeurpar défaut

� un constructeur ne retourne rien� l'identificateur d'un constructeur est toujours le

nom de la classe


UUCCLLBB

60


� Exemple : interface Rationnel.hclass Rationnel { private : //--- attributs de la classe Rationnel int n; // numérateur int d; // dénominateur

public : //--- méthodes de l'interface de la classe Rationnel // constructeur par défaut Rationnel(){n=0; d=1;} // définition en ligne // surcharge constructeur Rationnel(int x, int y=1); ... }; // fin classe Rationnel


UUCCLLBB

61


� Exemple : réalisation Rationnel.cpp

#include "Rationnel.h"

//--- Définition des fonctions membres --------------

// définition du constructeurRationnel::Rationnel(int x, int y){ n=x; d=y;}

...


UUCCLLBB

62

Constructeur par copieConstructeur par copieConstructeur par copie

� Constructeur qui sert à créer des clones d'objets�création d'un nouvel objet ayant les mêmes valeurs qu'un

autre objet de même type (clonage)�implicitement appelé chaque fois qu'un objet est initialisé

par un autre objet de la même classe

� Si aucun constructeur par copie n'est défini, lecompilateur effectue une copie membre à membre

�satisfaisant dans la plupart des cas�MAIS il existe des situations où la recopie membre à

membre n'est pas correcte


UUCCLLBB

63


� Cas où la recopie membre à membre est incorrecte

� lorsqu’un objet�comprend un pointeur comme attribut�il ne faut pas cloner le pointeur�mais la zone pointée

�DONC dans ce genre de situation, il faut écrire unconstructeur par copie pour obtenir le résultatsouhaité


UUCCLLBB

64


� Caractéristiques d'un constructeur par copie

� reçoit en paramètre une référence à un objet de laclasse d'appartenance (l'objet à cloner)

� duplique les zones mémoires allouéesdynamiquement

� chaîne correctement les pointeurs


UUCCLLBB

65

Clonage de 2 objets de lamême classe

Clonage de 2 objets de laClonage de 2 objets de lamême classemême classe

pointeur valeur

pointeur

Objet à copier

Objet copié

pointeur valeur

Objet à copier

pointeur valeur

Objet copié

Erreur de clonage Clonage correct


UUCCLLBB

66

Le destructeurLe destructeurLe destructeur� Le destructeur est une fonction membre particulière

qui libère la mémoire occupée par l'objet� il n'a ni paramètres ni de valeur de retour� il porte le nom de la classe précédé du signe ~

� Il est toujours appelé implicitement à la fin de laportée de l'objet

� Un appel explicite au destructeur n'a pas d'effet surla gestion de la mémoire ( nettoie l'objet MAIS nelibère pas la place mémoire)


UUCCLLBB

67

Le destructeurLe destructeurLe destructeur� Il n'est pas nécessaire de définir un destructeur s'il

n'y a pas de traitement particulier à faire lors de ladestruction de l'objet

� Cas où il faut définir un destructeur� lorsque l'objet comprend comme donnée membre un

pointeur sur une zone mémoire, le destructeur pardéfaut supprime uniquement le pointeur

� pour une suppression correcte de l'objet, il faut écrireun destructeur qui assure la restauration desressources mémoires par un delete


UUCCLLBB

68

Personnalisation d'undestructeur

Personnalisation d'unPersonnalisation d'undestructeurdestructeur

pointeur valeur

Objet

Destructeur incorrect Destructeur correct

pointeur valeur

Objet

�

�


UUCCLLBB

69

InstanciationInstanciationInstanciation� L'instanciation

� c'est la création d'un objet d'une classe avecinitialisation des données grâce au constructeur

� se fait soit par une déclaration d'objet soit par lemécanisme d'allocation dynamique

� Allocation statique d'un objet� précise la classe d'appartenance de l'objet� et le constructeur utilisé

// appel constructeur par défaut NomClasse NomObjet;// appel à un constructeur surchargé (s'il existe)NomClasse NomObjet(param);


UUCCLLBB

70

InstanciationInstanciationInstanciation

� Allocation dynamique d'un objet� il faut définir un pointeur sur le type d'objet

souhaité� allouer dynamiquement de la mémoire dans la pile

�dans ce cas l'opérateur new appelle un constructeur�on affecte ensuite le résultat au pointeur// déclaration d'un pointeurNomClasse * PtObjet;// affectation avec appel constructeur par défautPtObjet = new NomClasse;// appel à un constructeur surchargé (s'il existe)PtObjet = new NomClasse(param);


UUCCLLBB

71

Accès depuis l'extérieurAccès depuis l'extérieurAccès depuis l'extérieur

� L'accès à un membre d'une classe n'est possibledepuis l'extérieur que s'il est déclaré public(normalement ne concerne pas les données)� s'il s'agit d'un objet instancié statiquement la syntaxe

est�NomObjet.NomMembre pour les données�NomObjet.NomFonction(param) pour les fonctions

� s'il s'agit d'un objet créé dynamiquement, l'accès sefait via un pointeur�PtObjet->NomMembre pour les données�PtObjet->NomFonction(param) pour les fonctions


UUCCLLBB

72

Portée d'un objetPortée d'un objetPortée d'un objet

� Précise les parties du code où un objet peut êtreatteint (utilisé)

� Si l'objet est créé dynamiquement�la mémoire allouée est dans la pile�donc cette zone mémoire est visible tant qu'elle n'a

pas été détruite�la destruction de l'objet se fait par delete, ce qui

appelle dans ce cas le destructeur� Si l'objet est créé statiquement, il n'est visible que

dans le bloc où il a été déclaré, le destructeurétant appelé à la sortie du bloc automatiquement


UUCCLLBB

73

Le pointeur thisLe pointeur Le pointeur thisthis

� this� pointeur constant contenant l'adresse de l'objet lui-

même de type NomClasse * const� paramètre caché de chaque fonction membre qui

dispose ainsi de l'adresse de l'objet propriétaire� ne peut pas être explicitement déclaré

� * this� désigne l'objet lui-même� est de type NomClasse ou NomClasse &


UUCCLLBB

74

Le pointeur thisLe pointeur Le pointeur thisthis

� Intérêt� permet de retourner l'objet lui-même dans une

méthode� permet de vérifier lorsqu'une méthode d'objet

attend en argument un objet de même type, que leparamètre n'est pas l'objet lui-mêmeChaine & Chaine::operator = (const Chaine & source) {

if (this != & source) { .. .. } return * this;

}


UUCCLLBB

75

Membres statiquesMembres statiquesMembres statiques

� Les membres statiques sont spécifiés par le motréservé static

� Une variable membre statique est partagée partoutes les instances la même classe� syntaxe

class NomClasse{private: static type NomVar;

. . .};

� initialisation réalisée en dehors de la classe partype NomClasse :: NomVar = valeur;


UUCCLLBB

76

Membres statiquesMembres statiquesMembres statiques� Une constante membre statique est partagée par

toutes les instances la classe� syntaxe

class NomClasse{private: static const type NomVar;

. . .};

� initialisation réalisée en dehors de la classe partype NomClasse :: NomVar = valeur;

� ou encore à l'intérieur de la classe pour lesconstantes de type arithmétique static const type NomVar = valeur;


UUCCLLBB

77

Membres statiquesMembres statiquesMembres statiques� Une fonction membre statique a une existence en

dehors de tout objet� elle ne peut accéder qu'aux membres statiques� elle ne peut pas utiliser le pointeur this� syntaxe

class NomClasse{private: static type NomFonc(param);

. . .};

� définition soit en ligne soit en dehors de la classetype NomClasse :: NomFonc (param) { .. .. }


UUCCLLBB

78

Membres constantsMembres constantsMembres constants

� Une constante membre� spécifiée par le mot réservé const

const type NomConst;

� l'initialisation se fait obligatoirement dans chaqueconstructeur par une liste d'initialisation�soit dans la classeNomClasse(param) : NomConst (valeur ou param) {.. .. }

�soit en dehors de la classeNomClasse::NomClasse(param):NomConst1(valeur ouparam), NomConst2(valeur ouparam){.. ..}


UUCCLLBB

79

Membres constantsMembres constantsMembres constants

� Une fonction constante� fonction membre de la classe qui ne modifie pas

l'état de l'objet� spécifiée par le mot réservé const

�dans le prototypage de la fonction type NomFonction(param) const;

�ET dans la définition de la fonction type NomFonction(param) const{.. ..}


UUCCLLBB

80

Pointeurs sur membresPointeurs sur membresPointeurs sur membres

� Pointeur externe à la classe défini en précisant letype du membre et la classe d'appartenance

� Syntaxe type NomClasse:: * NomPointeur;

� Pour accéder à un membre de classe à travers unpointeur on utilise l'opérateur .*

� Pour accéder à un membre de classe pointé parun pointeur, la classe étant elle même pointée parun pointeur on utilise l'opérateur ->*


UUCCLLBB

81

Pointeurs sur membresPointeurs sur membresPointeurs sur membres� Déclaration d'un pointeur ptr sur membre de type entier de

la classe Cint C::*ptr;

� Le pointeur ptr pointe sur le champ X de type int d'unobjet O de C

C O; //déclaration d'un objet O de Cptr=&C::X; //ptr pointe sur l'entier X de la classe C

� Le champ X prend valO.*ptr = val; //x vaut val

Objet O de la classe C

X val ptr


UUCCLLBB

82

Pointeurs sur membresPointeurs sur membresPointeurs sur membres

� Déclaration� d'un pointeur ptclasse sur un objet de la classe C

C * ptclasse = new C;

� d'un pointeur ptr sur membre de C de type entierint C::* ptr;

� Le pointeur ptr pointe sur le champ X de la classe C ptr = &C::X;

� Le champ X de l'objet pointé parptclasse prend 1

ptclasse->*ptr=val;

ptr

ptclasse

X 1


UUCCLLBB

83

AmitiéAmitiéAmitié� Mécanisme qui permet de contourner les règles

de contrôle d'accès aux membres (✭ danger)� Fonction amie d'une classe

� fonction non membre de la classe mais qui a ledroit d'accéder à tous les membres même privés dela classe

� spécifiée dans la classe à l'aide du mot friendclass NomClasse {

friend type NomFonction(param);.. .. ..

}


UUCCLLBB

84

AmitiéAmitiéAmitié

� Classe amie d'une classe� une classe A amie d'une classe B est autorisée à

accéder à tous les membres de B même privés� la classe amie se déclare ou se définit en partie

privée ou publique

class B{.. ..friend class A; // classe A amie de la classe B.. ..

}


UUCCLLBB

85

La surchargeLa surchargeLa surcharge

� Mécanisme qui permet de définir plusieurscomportements possibles� d'une méthode de classe�mais aussi d'un opérateur

� On parle alors de méthode surchargée (cf. coursdu C au C++)

� Ou d'opérateur surchargé


UUCCLLBB

86

Surcharge de fonctionSurcharge de fonctionSurcharge de fonction

� La surcharge d'une fonction� c'est définir différentes versions qui portent le

même identificateur� différencier entre elles par les types de leurs

arguments� Ce qui permet de s'affranchir du problème de

représentation interne en machine des types� Le compilateur choisit une des versions de la

fonction surchargée grâce à un système designature


UUCCLLBB

87

Surcharge de fonctionSurcharge de fonctionSurcharge de fonction

� Les fonctions sont signées à partir des types deleurs arguments

� La moindre ambiguïté génère une erreur à latraduction� les règles de conversion entre type peuvent

introduire des erreurs� les arguments par défaut aussi� le type de la valeur retournée ne peut pas servir à

discriminer les différentes versions


UUCCLLBB

88

Surcharge d'opérateurSurcharge d'opérateurSurcharge d'opérateur

� La surcharge d'un opérateur permet

� d'appliquer ce même opérateur sur des typesdifférents

� en le dotant d'une sémantique particulière suivant lestypes pour lesquels il est surchargé

� Tous les opérateurs courants peuvent êtresurchargés


UUCCLLBB

89


� La surcharge d'un opérateur appelé par exemple op

� revient à créer une fonction membre operator opde sorte que la notation (x op y) est identique à lanotation (x.operator op(y))

�ATTENTION si l’opérande de gauche (ici x) n ’est pasun objet de la classe, l’opérateur doit alors être définipar une fonction en dehors de la classe et déclaréeamie pour accéder aux données privées


UUCCLLBB

90


� Cas où la fonction operator op est une fonctionmembre de la classe� nombre de paramètres = pluralité de l'opérateur - 1� le premier opérande est l’objet propriétaire� une construction de type x op y est interprétée

comme un appel à (x.operator op(y))� l’opérateur d’affectation par défaut du C++ effectue

une copie membre à membre, il faut donc souventle redéfinir dès lors qu ’il y a allocation dynamique


UUCCLLBB

91


� Exemple: surcharge de l'opérateur = classe Chaine� interface Chaine & operator = (const Chaine &);� réalisation

Chaine & Chaine::operator = (const Chaine & source) { if (this != & source) { delete [] s; s=new char[strlen(source.s) + 1]; if (!s) max=0; else { strcpy(s,source.s); max= (int) strlen(source.s); } } return *this;}


UUCCLLBB

92

Surcharge d'opérateurSurcharge d'opérateurSurcharge d'opérateur� Si le fonction operator op est une fonction non

membre de la classe� nombre de paramètres = pluralité de l'opérateur� tous les opérandes sont des paramètres de la

fonction� une construction de type x op y est interprétée

comme un appel à operator op(x,y)� obligatoire si on veut une symétrie de l'expressionx op y et y op x ou si l’opérande de gauchen’est pas un objet de la classe

� pour accéder aux champs de l'objet on utilisel'amitié


UUCCLLBB

93


� Exemple: surcharge de l'opérateur + de la classeComplexe� interface

friend Complexe operator + (Complexe, Complexe);� définition

Complexe operator + (Complexe c1, Complexe c2){Complex c;c.r = c1.r + c2.r;c.i = c1.i + c2.i;return c;

}


UUCCLLBB

94

Surcharge d'opérateurSurcharge d'opérateurSurcharge d'opérateur� Pour assurer un traitement uniforme des E/S, le

concepteur d'une classe est souvent amené� à surcharger l'opérateur >> de la classe istream� et l'opérateur << de la classe ostream

� Exemple pour la classe Chaine� interface

// opérateur ami <<friend ostream & operator << (ostream & stream, const Chaine &);

//opérateur ami >>friend istream & operator >> (istream & stream, Chaine &);


UUCCLLBB

95

Surcharge d'opérateurSurcharge d'opérateurSurcharge d'opérateur� Exemple pour la classe Chaine (suite)

� définitionostream & operator << (ostream & stream, const Chaine & ch){ return ( stream << ch.s);}

istream & operator >> (istream & stream, Chaine & ch){ stream >> ch.s; return ( stream );

}


UUCCLLBB

96

ExemplesExemplesExemples


UUCCLLBB

97

Premier exemple C++Premier exemple C++Premier exemple C++

� Le premier exemple proposé est très simple� on veut créer une classe appelée Animal

�données membres: le nom de l'animal�fonctions membres: un constructeur, un destructeur

et une méthode d'affichage� on utilise pour cela les services d'une classeChaine supposée déjà écrite (objet primitif)

� il faut donc écrire les fichiers Animal.h etAnimal.cc

� puis le programme test_animal.cpp qui permetde tester la classe Animal


UUCCLLBB

98


� Interface de la classe� utilisation de la constante

symbolique ANIMAL_H_ pouréviter les inclusions multiples

� inclusion de l'interface de laclasse Chaine (objet primitif)

� définition des attributs privéspar le spécificateur d'accèsprivate

� prototype des méthodespubliques (public)� constructeur par défaut� destructeur� affichage qui ne modifie pas

l’état de l’objet par const

//========================================// Animal.h :interface de la classe Animal// traduction en c++ des exemples// Cobol Objet de Nino SILVERIO//========================================

#ifndef ANIMAL_H_#define ANIMAL_H_

#include "Chaine.h"

class Animal{ private : Chaine nom_animal;

public : Animal(); ~Animal(); void affiche() const;};

#endif


UUCCLLBB

99

Premier exemple C++Premier exemple C++Premier exemple C++� Réalisation de la classe

� inclusion de l'interfaceAnimal.h

� définition du constructeur (unconstructeur porte toujours lenom de la classe)

� personnalisation du destructeur(un destructeur porte le nom dela classe précédé de ~)

� définition de la méthode affiche� la définition d'une méthode

est toujours précédée deNomClasse::

� const indique une méthodeconstante

//==========================================// Animal.cc: realisation de la classe Animal//==========================================

#include "Animal.h"

// ConstructeurAnimal::Animal(){ cout <<"\n"<<"Entrez le nom de l'animal : "; cin >> nom_animal;}

// DestructeurAnimal::~Animal(){cout <<"\n L'animal "<<nom_animal;cout <<" est supprime \n";}

// Methode affichevoid Animal::affiche() const{ cout<<"\n Nom de l'animal : "<< nom_animal;}


UUCCLLBB

100


� Utilisation de la classeAnimal� inclusion de l'interface de la

classe Animal.h� instanciation d'un objet a1 de

la classe par Animal ce quiappelle automatiquement leconstructeur

� la méthode affiche() estinvoquée en envoyant unmessage à l'objet a1 para1.affiche();

� fin du programme et appel audestructeur pour supprimer a1

//===========================================// test_animal.cc : test de la classe Animal////===========================================

/*--- Inclusion des headers necessaires ---*/#include "Animal.h"

/*--- Point d'entree du programme ---------*/int main() {

// instanciation de l'objet a1 Animal a1;

// appel a la methode affiche a1.affiche();}


UUCCLLBB

101

Deuxième exemple C++Deuxième exemple C++Deuxième exemple C++

� Le deuxième exemple proposé est la constructiond’une classe technique rudimentaire� on veut créer une classe appelée Tableau qui gère

des tableaux d’entiers de n’importe quelle taille� l’allocation du tableau est donc dynamique� les méthodes proposées ici ne le sont que dans un

but d’illustration du langage�REMARQUE: le C++ dispose de mécanismes plus

riches pour construire une classe tableau, mais ilssont abordés plus loin dans le cours


UUCCLLBB

102

Deuxième exemple C++Deuxième exemple C++Deuxième exemple C++� Interface de la classe

� définition de TAB_H_ pour éviterles inclusions multiples

� inclusion des headersnécessaires

� définition de la constanteTAILLE en dehors de la classe

� définition des attributs privéspar le spécificateur d'accèsprivate

� définition d'une variable declasse par le qualificateurstatic

� prototypage de plusieursconstructeurs surchargés

//========================================================// tab.h: interface de la classe Tableau d'entiers sans// doublons les elements ne sont pas maintenus tries//========================================================#ifndef TAB_H_#define TAB_H_

//--- Inclusion des headers ------------------------------#include <stdio.h>#include <time.h>#include <stdlib.h>#include <iostream.h>

//--- Definition des constantes --------------------------const int TAILLE=5;

//--- Definition des classes -----------------------------class Tableau{ private : //--- attributs de la classe tableau int * tab; // adresse du tableau int nb_elem; // nombre d'elements presents int taille; // taille du tableau

//--- variable commune a toutes les instances static int nb_objet; // nombre d'objets instancies public : //--- methodes publiques Tableau(); Tableau(int nb); ~Tableau();


UUCCLLBB

103

Deuxième exemple C++Deuxième exemple C++Deuxième exemple C++� Suite de l’interface

� définition en ligne de laméthode nombre_el()

� déclaration d’une méthodeamie de comparaison

� annonce de la surcharge del ’opérateur []

� prototypage des méthodesprivées

� la méthode compter est uneméthode de classe

� définition en ligne de compteren dehors de la classe

� fin de l’interface par endif

public :int inserer(int el);

int supprimer(int el); void remplir(int nb); void afficher() const; int nombre_el() const { return nb_elem; } bool comparer(const Tableau &) const; friend bool comparer_amie(const Tableau &, const Tableau &);

const int & operator [] (int);

private : //--- methodes privees (donc cachees) int rechercher(int el) const;

//--- methode de classe static void compter(int nb_occ);

}; // fin classe Tableau

//--- Definition des methodes en ligne -------------

inline void Tableau::compter(int nb_occ){ nb_objet=nb_objet+nb_occ; cout<<"\nNombre d'objets instancies : "<<nb_objet;}

#endif //--- fin de tableau.h ----------------------


UUCCLLBB

104

Deuxième exemple C++Deuxième exemple C++Deuxième exemple C++� Réalisation (extraits)

� inclusion de l’interface

� initialisation de la variable declasse nb_objet

� définition du constructeur pardéfaut

� surcharge du constructeur dela classe

//--- Inclusion de l'interface -------------------#include "tab.h"

//--- Initialisation des donnees membres statiquesint Tableau::nb_objet=0;

//--- Definition des constructeursTableau::Tableau(){ tab=new int[TAILLE]; if (tab!=NULL) { taille=TAILLE; compter(+1); } else taille=0; nb_elem=0;}

Tableau::Tableau(int nb){ tab=new int[nb]; if (tab!=NULL) { taille=nb; compter(+1); } else taille=0; nb_elem=0;}


UUCCLLBB

105

Deuxième exemple C++Deuxième exemple C++Deuxième exemple C++� Réalisation (extraits)

� ici il faut personnaliser ledestructeur car on doit libérerla mémoire allouée de façondynamique

� définition de la méthodeinserer()

� définition de l ’opérateur []qui retourne un entier

� de même pour les autresfonctions sauf pour laméthode amie qui n’est pasune méthode de classe

Tableau::~Tableau(void){ delete [] tab; compter(-1);}

int Tableau::inserer(int el){ // si tableau plein if (nb_elem>=taille) return -1; // si element deja present if (rechercher(el)!=-1) return -1; // sinon on le place en fin du tableau tab[nb_elem]=el;

return ++nb_elem;}

const int & Tableau::operator [] (int index){ return tab[index];}


UUCCLLBB

106

Deuxième exemple C++Deuxième exemple C++Deuxième exemple C++� Test de la classe (extraits)

� instanciation de l’objet t1� instanciation par allocation

dynamique d’un objet de typeTableau pointé par ptobj

� exemples d’appel aux méthodes�remplir pour l’objet t1�inserer pour l’objet pointé

par ptobj� appel à l’opérateur [] de la

classe Tableau� comparaison par la méthode de

classe et la méthode amie

// objet t1 = instance de la classe TableauTableau t1; // constructeur par défaut

// définition d'un pointeur sur la classeTableau * ptobj;// instanciation avec appel au// deuxième constructeurptobj = new Tableau(10);... ...

t1.remplir(TAILLE);indice = ptobj->inserer(elem);... ...

cout <<"test de l'operateur [] ";cout <<"l'element est : "<<t1[rang];

... ...

if (t1.comparer(*ptobj)==true) ..

... ...

if (comparer_amie(t1, *ptobj)==true) ..


UUCCLLBB

107

Chapitre III

L'héritageL'héritageL'héritage


UUCCLLBB

108

DéfinitionDéfinitionDéfinition

� Mécanisme qui permet de définir une classe diteclasse dérivée, à partir d’une classe plus généraledite classe de base� la classe dérivée hérite des caractéristiques de la

classe de base� la classe dérivée peut ajouter des données

membres données et/ou des fonctions membres� la classe dérivée peut adapter des fonctions

membres de la classe de base sans que cela lesmodifie au niveau de la classe de base


UUCCLLBB

109

Principe de substitutionPrincipe de substitutionPrincipe de substitution

� Principe de Liskow : un objet d’une classedérivée doit pouvoir être utilisé à tout endroit oùon attend un objet de la classe ancêtre

� L’inverse n’est pas vrai

� Les liens d’héritage� forment un arbre dans le cas de l’héritage simple� forment un graphe acyclique dans le cas de

l’héritage multiple


UUCCLLBB

110

Héritage simpleHéritage simpleHéritage simple� L'héritage simple permet d'implanter une nouvelle

classe (appelée encore sous-classe ou classedérivée) à partir d'une classe mère

� Intérêts:�factorisation des connaissances : la sous-classe

hérite des propriétés de la classe mère (attributs etméthodes non privés)

�spécialisation: la sous-classe peut redéfinir desattributs ou des méthodes de la classe mère

�extension: la sous-classe peut ajouter des nouveauxattributs ou des nouvelles méthodes


UUCCLLBB

111

Héritage simpleHéritage simpleHéritage simple� La hiérarchie d'héritage simple entre les classes

est décrite suivant un arbre

� L'héritage simple traduit la spécialisation ou lagénéralisation (lien de type "est un")� la spécialisation = relation entre classes permettant

le partage des propriétés communes tout enmettant en avant la particularité d'une sous-classe

� la généralisation = relation entre classes permettantde factoriser les propriétés des sous-classes dansune super-classe


UUCCLLBB

112

Héritage multipleHéritage multipleHéritage multiple� L'héritage multiple permet d'implanter une

nouvelle classe (sous-classe) à partir de plusieursclasses mères

� Même mécanisme d'héritage qu'avec l'héritagesimple mais avec toutes les classes d'oùcomplexité� encore plus de partage d'informations� possibilité de conflits de noms lorsqu'on invoque

une méthode� La hiérarchie d'héritage entre les classes est

décrite suivant un graphe orienté sans cycle


UUCCLLBB

113

Les contrôles d'accèsLes contrôles d'accèsLes contrôles d'accès

� Syntaxe pour indiquer l’héritageclass NomClasseDerivee : ModifAccess NomClasseBase{..};

� Le modificateur d’accès précise la propagationdes droits donc la visibilité� public� private� protected


UUCCLLBB

114

Les contrôles d'accèsLes contrôles d'accèsLes contrôles d'accès� Les droits de la classe dérivée sur les membres de

la classe de base dépendent des droits d’accès dela classe de base et du modificateur d’accès

Accès classe de base Modificateur d'accès Accès classe dérivéepublic public publicprivate public non accessibleprotected public protected

public private privateprivate private non accessibleprotected private private

public protected protectedprivate protected non accessibleprotected protected protected


UUCCLLBB

115

Les contrôles d'accèsLes contrôles d'accèsLes contrôles d'accès� Règles:

� les fonctions membres d'une classe dérivée peuventaccéder aux membres public et protected de laclasse de base

� les membres private de la classe de base restentinaccessibles aux membres de la classe dérivée

� un utilisateur d'une classe dérivée n'accède qu'auxmembres public de cette classe

� une classe dérivée n’hérite pas�des constructeurs de la classe de base�des destructeurs de la classe de base�des fonctions amies de la classe de base


UUCCLLBB

116

Cas des constructeursCas des constructeursCas des constructeurs

� Lors de l’instanciation d’une classe dérivée� il y a appel en cascade de tous les constructeurs

des classes parents� en commençant par la classe parent au sommet de

la hiérarchie� Le constructeur d’une classe dérivée

� peut faire explicitement appel au constructeur de laclasse de base

� en lui passant des paramètres grâce à une listed’initialisation (voir l'exemple plus loin)


UUCCLLBB

117

Redéfinition des membresRedéfinition des membresRedéfinition des membres� La redéfinition dans une classe dérivée d'une

donnée membre de la classe de base�masque la donnée issue de la classe de base� la classe dérivée peut toujours atteindre la donnée de

la classe de base par NomClasseBase::Nomdonnée� De même la redéfinition dans une classe dérivée

d'une méthode de la classe de base�masque la fonction issue de la classe de base� la classe dérivée peut atteindre la fonction de la classe

de base par NomClasseBase::Fonction(param);� Ceci est vrai dans toute la hiérarchie d'héritage


UUCCLLBB

118

Exemple (présentation)Exemple (présentation)Exemple (présentation)

� Soit le cas simpliste de gestion du personnel� tous les salariés ont un nom� on leur affecte un bureau et un numéro de téléphone� on distingue

�les employés payés à un certain taux horaire�des commerciaux qui perçoivent un pourcentage des

ventes réalisées en plus d'un salaire de base� on ne s'intéresse ici dans l'exemple qu'aux

constructeurs et aux méthodes affiche() etcalcul_paie()


UUCCLLBB

119

Exemple (arbre d'héritage)Exemple (arbre d'héritage)Exemple (arbre d'héritage)

Personnel

nom, bureau, téléphone

affiche(), …..

Employé

taux, heures

affiche(), calcul_paie()…..

Commercial

Ventes, pource



UUCCLLBB

120

Exemple (extraits de l'interface)Exemple (extraits de l'interface)Exemple (extraits de l'interface)

� L'interface regroupe la description des classesPersonnel, Employé et Commercial

� class Personnel {private: Chaine nom; // nom d'un salarie

ushort bureau; // numéro du bureau du salarie Chaine telephone; // numéro de téléphonepublic: Personnel (Chaine, ushort num_bureau = 0,

Chaine num_tel = "00"); void affiche() const; .. .. ..

}; // class Personnel


UUCCLLBB

121

Exemple (extraits de l'interface)Exemple (extraits de l'interface)Exemple (extraits de l'interface)

� class Employe : public Personnel {private:

float taux; // taux horaire float heures; // nombre d'heures travailléespublic:Employe (Chaine, ushort num_bureau=0,

Chaine num_tel= "00", float val_taux=0.0, float nb_heures=0.0 );void affiche() const;float calcul_paie() const;

.. ..}; // class Employé


UUCCLLBB

122

Exemple (extraits de l'interface)Exemple (extraits de l'interface)Exemple (extraits de l'interface)� class Commercial : public Employe {

private: float pourcent; // montant du pourcentage float ventes; // montant des ventes dans le mois public:

Commercial (Chaine, ushort num_bureau=0, Chaine num_tel="00", float val_taux=0.0, float nb_heures=0.0, float val_pourcent=0.0, float val_ventes=0.0 );

void affiche() const; float calcul_paie() const; .. ..

}; // class Commercial


UUCCLLBB

123

Exemple (extraits de la réalisation)Exemple (extraits de la réalisation)Exemple (extraits de la réalisation)

� La réalisation comprend la définition desméthodes des différentes classes

� On se limite ici à la définition� des constructeurs� de la méthode affiche() de chacune des classes� de la méthode calcul_paie()


UUCCLLBB

124


� Constructeur de la classe Personnel

Personnel::Personnel(Chaine nom_salarie, ushort num_bureau, Chaine num_tel)

{nom = nom_salarie; // opérateur = de la classe Chaine

bureau = num_bureau;if (bureau == 0) // pas encore affecte à un bureau

telephone = "00"; // donc pas de telephoneelse

telephone = num_tel;}


UUCCLLBB

125


� Constructeur de la classe Employe� fait appel explicitement au constructeur dePersonnel avec une partie de ses propres arguments

� puis initialise les données membres de la classe� utilise le mécanisme de liste d'initialisation

Employe::Employe(Chaine nom_salarie, ushort num_bureau, Chaine num_tel, float val_taux, float nb_heures)

: Personnel (nom_salarie, num_bureau, num_tel), taux(val_taux), heures(nb_heures){}


UUCCLLBB

126


� Constructeur de la classe Commercial�même mécanisme de liste d'initialisation� ici le constructeur appelle d'abord le constructeur deEmploye qui appelle en premier le constructeur dePersonnel

Commercial::Commercial(Chaine nom_salarie, ushort num_bureau, Chaine num_tel, float val_taux,float nb_heures, float val_pourcent, float val_ventes) :Employe(nom_salarie, num_bureau,num_tel, val_taux, nb_heures), pourcent(val_pourcent), ventes(val_ventes){}


UUCCLLBB

127


� Méthode affiche de la classe Personnelvoid Personnel::affiche() const{

cout << \n--- Informations salarie --- \n";cout << "nom : " << nom << "\n";

if (bureau == 0) cout << "n'a pas encore de bureau affecte \n";

else cout << "bureau numero : "<< bureau <<"\n"; if (telephone == "00") // opérateur == de Chaine cout << "n'a pas encore de téléphone affecte \n";

else cout << "numéro de téléphone : " << telephone;

}


UUCCLLBB

128

Exemple (extraits de la réalisation)Exemple (extraits de la réalisation)Exemple (extraits de la réalisation)� Méthode affiche()des classes dérivées

void Employe::affiche() const{

Personnel::affiche(); // affiche de la classe Personnelcout << "taux horaire : " << taux << "\n";cout << "nombre d'heures travaillées : "<<heures<< "\n";

}

void Commercial::affiche() const{

Employe::affiche() ; // affiche de la classe Employe cout << "pourcentage de commission : " << pourcent; cout << "\n montant des ventes : " << ventes << "\n";}


UUCCLLBB

129

Exemple (extraits de la réalisation)Exemple (extraits de la réalisation)Exemple (extraits de la réalisation)� Méthode calcul_paie()de la classe Employe

float Employe::calcul_paie() const{

return taux * heures;}

� Méthode calcul_paie()de la classe Commercial

float Commercial::calcul_paie() const{

return Employe::calcul_paie() + pourcent * ventes;}


UUCCLLBB

130

� Le polymorphisme traduit la capacité d'uneméthode à prendre plusieurs formes

� Principe : associer à un même message� pour des objets d'une même hiérarchie de classes� l'exécution d'une méthode différente selon la

classe d'appartenance de l'objet

� Techniques� liaison statique� liaison dynamique

Le polymorphismeLe polymorphismeLe polymorphisme


UUCCLLBB

131

Le polymorphismeLe polymorphismeLe polymorphisme� Liaison statique

� désigne la surcharge d'une méthode c'est à dire sacapacité à s'appliquer sur des types différents

� la résolution de la méthode à invoquer est faite à lacompilation car il n'y a pas d'ambiguïté


UUCCLLBB

132

Le polymorphismeLe polymorphismeLe polymorphisme� Liaison dynamique

� désigne la possibilité d'envoyer un message demême nom à des objets appartenant à une mêmehiérarchie de classes dans le cadre de l'héritage

� le compilateur génère une table des fonctions quipeuvent être virtuellement invoquées

� la résolution est faite à l'exécution car elle dépendde la sémantique d'exécution


UUCCLLBB

133

Héritage et polymorphismeHéritage et polymorphismeHéritage et polymorphisme

� L'héritage traduit un lien de type "est un" ce quiimplique:� que tous les services offerts par la classe de base

le sont aussi par une des classes dérivées� que tout objet d'une clase dérivée peut être vu

comme un objet des classes de base dans lahiérarchie d'héritage

� Donc tout pointeur sur un objet de la classe debase peut également pointer sur un objet d'unedes classes dérivées


UUCCLLBB

134

Héritage et polymorphismeHéritage et polymorphismeHéritage et polymorphisme

� Le type pointé par un tel pointeur est alorsdéterminé� à la compilation s'il s'agit d'un type classe de base� à l'exécution s'il s'agit d'un type classe dérivée car il

peut avoir plusieurs classes dérivées� Il existe dans une même hiérarchie de classes des

méthodes surchargées qui n'effectuent pas lemême traitement suivant le niveau de la hiérarchie

� Cette capacité à effectuer des traitements différentssuivant le niveau de la hiérarchie auquel appartientl'objet pointé s'appelle le polymorphisme


UUCCLLBB

135

Héritage et polymorphismeHéritage et polymorphismeHéritage et polymorphisme� Le pointeur ptcl peut pointer

sur un objet� de la classe A� de n'importe quelle classe

dérivée B, C ou D� Donc le type de l'objet pointé

par ptcl varie en coursd'exécution:� type statique s'il s'agit d'un

objet de la classe de base� type dynamique s'il s'agit d'un

objet d'une des classesdérivées MAIS laquelle ?�dépend de l'exécution

Classe A

Classe B Classe C

Classe D

ptcl


UUCCLLBB

136

Héritage et polymorphismeHéritage et polymorphismeHéritage et polymorphisme� Dans le cas d'une même hiérarchie de classes, le

mécanisme mit en jeu

� permet d'associer au message une méthodedifférente selon la classe d'appartenance de l'objet

� cache les variations entre classes par laredéfinition dans chaque classe de la méthode enquestion

� On parle de méthodes virtuelles en C++


UUCCLLBB

137

VirtualitéVirtualitéVirtualité� La liaison dynamique est mise en œuvre en C++ grâce

aux fonctions virtuelles

�Une fonction virtuelle sert de fonction par défaut dansles classes dérivées où elle n'est pas redéfinie

�Une fonction déclaré virtuelle le reste pour toute lahiérarchie des classes dérivées

�Une fonction statique ne peut pas être virtuelle


UUCCLLBB

138

Fonction virtuelle pureFonction virtuelle pureFonction virtuelle pure

� Une fonction virtuelle pure est une méthode declasse� qui correspond à un niveau d'abstraction

supérieur� qui est une fonction virtuelle dont on ne peut pas

encore préciser le corps�mais qui le sera obligatoirement par la ou les

classes dérivées

� Déclarée dans l'interface par la syntaxe virtual type NomFonction() = 0;


UUCCLLBB

139

Classe abstraiteClasse abstraiteClasse abstraite� Classe qui représente une abstraction qui ne peut

être instanciée

� permet de décrire conceptuellement l'abstraction

�mais définit un cadre trop général pour implémentercomplètement l'abstraction

� donc délègue l'implémentation aux classes dérivées


UUCCLLBB

140

Classe abstraiteClasse abstraiteClasse abstraite� Une classe est abstraite

� si tous ses constructeurs sont privés

� ou si elle contient au moins une fonction virtuellepure

� Une classe dérivée qui n'implémente pas unefonction virtuelle pure est elle même une classeabstraite


UUCCLLBB

141

ExempleExempleExemple� A partir de l'exemple précédent

� on rajoute une classe dans la hiérarchie: lesdirecteurs qui perçoivent des indemnités

� on transforme la classe Personnel en classeabstraite


UUCCLLBB

142

ExempleExempleExemple

Personnel

nom, bureau, téléphone

affiche(), …..

Employé

taux, heures


Commercial

Ventes, pource


Directeur

indemnités



UUCCLLBB

143

Cas des conteneursCas des conteneursCas des conteneurs

� Dans le cas d'une collection d'objets appartenantà une même hiérarchie, il faut pouvoir disposerd'un conteneur implémenté par un objettechnique (tableau, liste, file, pile ,arbre,..)

� Un conteneur permet de stocker un ensembled'objets ou de pointeurs sur objets

� Il supporte au minimum les opérations� d'insertion� de suppression� de recherche


UUCCLLBB

144

Cas des conteneursCas des conteneursCas des conteneurs

� Mais quel alors est le type des éléments duconteneur dans un arbre d'héritage?

� Seule solution : il faut un conteneur dont leséléments sont de type pointeur sur classe debase

� S'il existent des méthodes de classessurchargées, elles doivent être virtuelles

� Ce qui permet d'invoquer les services desméthodes adéquates via les pointeurs duconteneur


UUCCLLBB

145

Exemple de Nino SILVERIOExemple de Nino SILVERIOExemple de Nino SILVERIO

� Programme d'illustration d'après "Programmer enCobol objet" de Nino SILVERIO [Eyrolles 1996]� une classe de base Animal d'attribut nom_animal� deux classes qui dérivent de la classe Animal

�la classe Chat attributs race et couleur�la classe Tortue attributs taille et poids

� par soucis de simplification on ne retient pour lestrois classes que la méthode affiche()

� la hiérarchie est donnée par le diagramme UMLsuivant


UUCCLLBB

146

Exemple de Nino SILVERIOExemple de Nino Exemple de Nino SILVERIOSILVERIO

Animal

# nom_animal

affiche()

Chat

# race# couleur

affiche()

Tortue

# poids# taille

affiche()


UUCCLLBB

147

Exemple de Nino SILVERIOExemple de Nino SILVERIOExemple de Nino SILVERIO� Le module utilisateur test_ménagerie.cc

� définit les fonctions ordinaires (non membres d'uneclasse) ajout_chat() et ajout_tortue() quipermettent d'ajouter un chat ou une tortue à notreménagerie

� utilise le conteneur bete pour stocker lespensionnaires de la ménagerie� il s'agit d'un tableau d'au plus MAX pointeurs sur des d'objets

de la classe Animal� il contient indifféremment des pointeurs sur des objets de la

classe Chat sur des objets de la classe Tortue� et une variable nombre_betes qui indique le nombre

de pensionnaires


UUCCLLBB

148

Exemple de Nino SILVERIOExemple de Nino SILVERIOExemple de Nino SILVERIO� La fonction main illustre le principe de liaison

dynamique� l'ajout d'animaux se fait grâce au conteneur bete

qui contient des pointeurs sur des objets soit de laclasse Chat, soit de la classe Tortue

� la méthode affiche() s'adresse suivant l'objetpointé à la classe Tortue ou à la classe Chat

� la résolution ne peut avoir lieu qu'à l'exécution caron ne peut savoir à l'avance si un poste de betepointe sur un objet de la classe Chat ou un objetde la classe Tortue


UUCCLLBB

149

//===========================================// test_menagerie.cc : test du polymorphisme//===========================================#include "Animal.h"

typedef Animal * PTA;

const int MAX=30;PTA bete[MAX];int nombre_betes=0;

void ajout_chat() { PTA ptchat; if (nombre_betes<MAX) { ptchat = new Chat; bete[nombre_betes]=ptchat; nombre_betes++; } else cout << "\n tableau plein \n";}

void ajout_tortue() { PTA pttortue; if (nombre_betes<MAX) { pttortue = new Tortue; bete[nombre_betes]=pttortue; nombre_betes++; } else cout << "\n tableau plein \n";}

Exemple de Nino SILVERIOExemple de Nino SILVERIOExemple de Nino SILVERIO� Inclusion de l'interface Animal qui

contient la description des classes dela hiérarchie (non précisée ici carsans intérêt)

� Définition� du type PTA pointeur sur type Animal� du tableau bete de variables PTA� du compteur nombre_betes

� La fonction ajout_chat()� instancie dynamiquement un objet de

type Chat� place le pointeur sur cet objet dans le

conteneur bete et incrémente lecompteur

� La fonction ajout_tortue()procède de même avec un objet detype Tortue


UUCCLLBB

150

Exemple de Nino SILVERIOExemple de Nino SILVERIOExemple de Nino SILVERIO� Dans la fonction main()

� on appelle la fonction ajout_chat()ou la fonction ajout_tortue()suivant le choix de l'utilisateur

� on invoque la méthode affiche()pour tous les objets du tableau bete

� La méthode affiche() utilisée estalors� par défaut celle de la classe mère

(liaison statique)� celle de la classe dérivée si la

méthode affiche() a été déclaréevirtuelle dans l'interface de la classemère Animal.h (liaison dynamique)

� idem pour les destructeurs

/*--- Point d'entree du programme --------*/void main(){ char choix; while ((choix=menu())!='0') { switch (choix) { case '1': ajout_chat(); break; case '2': ajout_tortue(); break; } /*fin du switch */ } /* fin du while */

cout<<"\n -- Affichage du tableau --\n"; for(int i=0;i<nombre_betes;i++) { bete[i]->affiche(); }

cout<<"\n\ -- Appel aux destructeurs --\n"; for(int j=0;j<nombre_betes;j++) { delete bete[j]; }}


UUCCLLBB

151

Exemple de Nino SILVERIOExemple de Nino SILVERIOExemple de Nino SILVERIO� Interface de la classe Animal (extraits)

� la méthode affiche() est déclaréevirtuelle pour supporter la liaisondynamique

� le destructeur est également déclarévirtuel

� le constructeur ne peut pas êtredéclarés virtuel

� grâce à l'accès protected l'attributnom_animal devient� accessible directement aux classes

dérivées� private si l'héritage est private� protected si l'héritage est public

//======================================// Animal.h : nouvelle interface de la// classe Animal////======================================#ifndef ANIMAL_H_#define ANIMAL_H_

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

class Animal{ protected: Chaine nom_animal;

public : Animal(); virtual ~Animal(); virtual void affiche() const;}; // class Animal

class Chat : public Animal{...}; // class Chat...#endif


UUCCLLBB

152

Chapitre IV

ComplémentsComplémentsCompléments


UUCCLLBB

153

Les E/SLes E/SLes E/S


UUCCLLBB

154

Les streamsLes Les streamsstreams

� Le C++ propose un ensemble de classes pour lagestion des E/S� les E/S sont implémentées par les streams appelés

aussi flots ou flux� un stream peut être représenté comme un buffer et

des mécanismes associés pour réaliser l'E/S� il existe quatre streams prédéfinis:

�cin : flux d'entrée standard�cout: flux de sortie standard�cerr: flux de sortie d'erreur non tamponné�clog: flux de sortie d'erreur tamponné


UUCCLLBB

155

Graphe partiel d'héritageGraphe partiel d'héritageGraphe partiel d'héritage

istream ostream

ifstream iostream ofstream

fstream

ios


UUCCLLBB

156

Les principales classes d'E/SLes principales classes d'E/SLes principales classes d'E/S

� La classe de base pour toutes les E/S s'appelle ios� elle est constituée à partir des classes ios_base etbasic_ios définies dans <ios>

� elle offre un grand nombre de fonctions applicablesà tous les objets des classes de la hiérarchie ios (seréférer à la documentation en ligne)�fonctions de contrôle de l'état d'un flux�fonctions de mise en forme d'un flux�plus des manipulateurs pour formater ou modifier le

fonctionnement d'un flux (voir <iomanip>)� elle n'est pas instanciable directement


UUCCLLBB

157


� Les classes istream et ostream� définies dans <iostream>� permettent un traitement uniforme pour tous les

types de base par surcharge des opérateurs >> et <<� surcharge possible pour tous les types construits

�ostream & operator << (ostream & s, const T &);�istream & operator >> (istream & s, T &);

� cin est une instance de istream, cout de ostream� proposent un ensemble de méthodes de lecture,

d'écriture, de positionnement, etc (voir la doc.)� iostream est la classe pour les flux bidirectionnels


UUCCLLBB

158


� Les classes ifstream, ofstream et fstream� définies dans <fstream>� permettent de traiter les flux connectés à un fichier� offrent un ensemble de méthodes pour gérer les

fichiers�ouverture�mode d'accès�fermeture�écriture�lecture


UUCCLLBB

159


� Exemples avec istream et ostreamchar c, s[15];cin.get(c); // saisie d'un caractèrecout.put(c); // affichage du caractère saisicin.ignore(1,'\n'); // filtrage du retour chariot

//saisie de la chaine s de 5 caractères max y compris \0cin.get(s,5,'\n'); // le délimiteur est '\n'

int n=127;cout << oct << n; // affiche 177 (127 en base 8)cout << hex << n; // affiche 7f (127 en base 16)cout.width(10); // largeur du champ affichécout.fill('*'); // caractères de remplissagecout << n; // affiche *******127


UUCCLLBB

160


� Exemples avec istream et ostream (suite)double x=6.6789, y=123.26754;cout<<setw(10)<<setfill('*')<< x; // affiche ****6.6789

// affichage d'un réel avec partie fractionnairecout.setf(ios::fixed,ios::floatfield);

// 3 chiffres après la virgule avec arrondicout << setprecision(3) << x; // affiche 6.679

// affichage d'un réel avec exposantcout.setf(ios::scientific,ios::floatfield);

// 4 chiffres après la virgule avec arrondicout << setprecision(4) << y; // affiche 1.2327e+002


UUCCLLBB

161


� Exemples avec fstreamchar car;// déclaration et ouverture d'un fichier// mode ouverture = écriture pour ofstreamofstream fich ("Essai.txt");while (cin.get (car)) // saisie au clavier fich.put (car); // écriture dans le fichierfich.close (); // fermeture du fichier

cout << "ouverture en mode lecture pour vérification \n";ifstream verif ("Essai.txt");while (verif.get (car)) cout.put (car);verif.close();


UUCCLLBB

162


� Exemples avec fstream// il est recommandé de tester si l'ouverture s'est// déroulée correctementfich.open ("Essai.txt", ios::out);if (!fich) {

cerr << "\nouverture fichier impossible";cerr << "\ntraitement interrompu";return -1;

}

// de même en écriturefich.open ("Essai.txt", ios::in);


UUCCLLBB

163

Les exceptionsLes exceptionsLes exceptions


UUCCLLBB

164


� Il existe plusieurs approches pour le traitement deserreurs� écrire des fonctions qui renvoient un code d'erreur

pour signaler une anomalie� terminer le programme par un appel à exit(val) en

testant la valeur de val au niveau de l'interpréteur decommandes ($? sous UNIX)

� utiliser la macro assert� Le C++ introduit maintenant un nouveau mécanisme

de traitement des erreurs: la gestion des exceptions


UUCCLLBB

165

Traitement par code retourTraitement par code retourTraitement par code retour� Le concepteur prévoie lors de l'écriture d'une

fonction une valeur (par exemple parmi uneénumération) pour signaler à l'appelant une erreurenum T_CDRU {T_ERREUR, T_OK};T_CDRU Tableau :: inserer(int elem) { if (nb_elem >= taille) return T_ERREUR; tab[nb_elem]=elem; nb_elem++; return T_OK;}

� Mais l'appelant ne sait pas toujours corriger l'erreuret ne teste pas forcément le code retour


UUCCLLBB

166

Traitement par exitTraitement par Traitement par exitexit

� Le concepteur considère dans ce cas qu'une erreurest rédhibitoire et qu'elle met fin à l'exécution duprogrammevoid Tableau :: inserer(int elem) { if (nb_elem >= taille) exit(1); tab[nb_elem]=elem; nb_elem++;}

� Mais il s'agit dans ce cas d'une sortie violente quireporte au niveau du shell la gestion du problème


UUCCLLBB

167

Traitement par assertTraitement par Traitement par assertassert

� Le concepteur prévoie ici un arrêt conditionnel par lamacro assert(condition) qui fait un exit si lacondition est faussevoid Tableau :: inserer(int elem) { // precondition: tableau non plein assert(nb_elem<taille); tab[nb_elem]=elem; nb_elem++;}

� Ceci est un bon moyen pour mettre au point le code� Mais reste une solution rudimentaire (la sortie est

brutale comme dans le cas avec exit)


UUCCLLBB

168

Les exceptionsLes exceptionsLes exceptions

� Principe� lorsqu'un appelant appelle une fonction susceptible

de lancer une exception, il peut se porter candidat àla gestion des exceptions par le bloc try

� lorsqu'une erreur survient dans la fonction appelée,cette dernière lance une exception par throw

� pour gérer l'erreur l'appelant intercepte l'exceptiongrâce au bloc catch (appelé gestionnaire)�tout gestionnaire dispose d'un paramètre dont le type

indique quelle sorte d'exception il sait traiter�une exception ne peut être interceptée que par un

gestionnaire de type compatible


UUCCLLBB

169

AvantagesAvantagesAvantages

� Le code retour des fonctions n'est plus réservé àla signalisation des erreurs

� Ce mécanisme permet aussi de gérer les erreurspour les constructeurs qui n'ont pas de valeur deretour

� Si en remontant dans la pile des appels aucungestionnaire d'exception adéquat n'a été prévupour le type d'erreur générée, l'erreur non traitéeconduit alors à l'arrêt du traitement


UUCCLLBB

170

Lancement d'une exceptionLancement d'une exceptionLancement d'une exception

� Le lancement d'une exception se fait poursignaler une erreur� syntaxe: throw expr où expr est une expression

de type quelconque sauf void� exemple: ici expr est de type const char *

void Tableau :: inserer(int elem) { if (nb_elem>=taille) // tableau plein throw "tableau plein"; tab[nb_elem]=elem; // sinon en fin de tableau ++nb_elem; }


UUCCLLBB

171

Interception d'une exceptionInterception d'une exceptionInterception d'une exception

� Pour pouvoir traiter une exception, il faut d'aborddéclaré un bloc qui est candidat pour intercepterles exceptions� syntaxe

try { NomFonction( ); // ou instructions;}

� le bloc try lance la fonction où les instructions quipeuvent générer une exception

� il doit être suivi du bloc catch


UUCCLLBB

172


� Il faut ensuite décrire le gestionnaire d'exceptiongrâce au bloc catch ()� syntaxe

catch (Type Nom) { ...; // traitement de l'exception;}

� précise le traitement à effectuer si une exception estlancée par throw expr

� seule une exception dont le type expr est compatibleavec le type Type de catch peut être traitée

� sinon son traitement est délégué en remontant dansles appels jusqu'à trouver un type correct de catch


UUCCLLBB

173


Void Fonc() {

...

if (probleme)

throw 3;

...

}

try {

Fonc();

}

catch (int x) {

...

}

...

...

type int


UUCCLLBB

174


� Exemple: // bloc trytry { // on invoque la méthode insérer sur l'objet t1 // cette méthode lance une exception de type const char * // si le tableau t1 est plein t1.inserer(elem);} // --- fin du bloc try

// bloc catch: intercepte des exceptions de type const char *catch (const char * msg) { cout << msg;} // --- fin du bloc catch


UUCCLLBB

175

Les modèlesLes modèlesLes modèles


UUCCLLBB

176


� Problème du typage des données� chaque type a une représentation interne particulière

(IEEE 754 pour les réels, C2 pour les entiers,etc )� et un certain nombre d'opérateurs associés (exemple

pour les int et les float l'égalité est testé parl'opérateur == alors que pour les char * il fautinvoquer la fonction strcmp de la bibliothèque)

�DONC pour une même méthode de résolution d'unproblème, l'implémentation doit se faire autant de foisqu'il y a de types différents

1 algorithme = n implémentations


UUCCLLBB

177

IntroductionIntroductionIntroduction� Pour augmenter la réutilisabilité du code, il faut

donc essayer de s'affranchir des types� Une première solution: écrire des fonctions

universelles qui s'appliquent indépendamment dutype (en C-ANSI ou en C++)� nombre élevé de paramètres� pointeur sur la ou les fonctions à utiliser dès lors que

son implémentation dépend du type� exemple: recherche d'un élément dans un tableau trié

Status_TABLEAU dichoto(void * tab, void * pt_el, int taille_el, int nb_elem,int (* ptf_cmp)(void *, void *), int * place) ;


UUCCLLBB

178

ModèleModèleModèle� Une autre solution offerte par le C++ est de

construire un modèle� il s'agit d'un mécanisme de généricité� qui permet d'instancier un modèle autant de fois qu'il

y a de types différents� l'instanciation du modèle

�est faite à la compilation suivant les besoins�n'est possible que si le compilateur peut produire le

code pour le type voulu, ce qui implique la surchargedes opérateurs utilisés

� On parle de template ou encore de patron


UUCCLLBB

179

GénéricitéGénéricitéGénéricité

� Un modèle (template)� permet de définir des modèles génériques de

classes et des modèles génériques de fonctions� alourdit le code mais n'altère pas l'efficacité à

l'exécution car tout se passe comme si leconcepteur avait écrit lui même le code pourchaque type

� est surtout mis en œuvre pour concevoir desobjets techniques

� La généricité et l'héritage peuvent être combinés


UUCCLLBB

180

Classe génériqueClasse génériqueClasse générique

� Une classe générique (ou modèle de classe) est untype paramètré qui se définit en� faisant précéder la définition de la classe partemplate <typename T>

� le mot template indique qu'il s'agit d'un modèle� le mot clé typename déclare le paramètre type� on peut utiliser class à la place de typename� T est le nom formel choisi ici pour nommer le

paramètre type� il peut y avoir plusieurs paramètres type pour un

même modèle (ex: template <class A, class B>)


UUCCLLBB

181

Exemple de classe génériqueExemple de classe génériqueExemple de classe générique

� Définition d'une classe générique Tableau_Basetemplate <typename T> class Tableau_Base { protected:

int taille; int nb_elem; T * tab;

public: Tableau_Base (int taille = TAILLE_DEFAUT); ~Tableau_Base (); int taille_tableau() const { return taille; }

int nombre_element() const { return nb_elem; } const T & operator [] (int);};


UUCCLLBB

182

Exemple d'héritage demodèle

Exemple d'héritage deExemple d'héritage demodèlemodèle

� Définition de la classe Tableau_Trié qui hérite dela classe générique Tableau_Base

template <typename T>class Tableau_Trie: public Tableau_Base <T> { public: Tableau_Trie(int nb): Tableau_Base <T> (nb) {} Tableau_Trie(): Tableau_Base <T> () {} T_CDRU rechercher(int & place, T elem) const; T_CDRU inserer(int & place, T elem); T_CDRU supprimer(int & place, T elem);};


UUCCLLBB

183

Méthodes d'une classegénérique

Méthodes d'une classeMéthodes d'une classegénériquegénérique

� Les fonctions membres d'une classe génériquequi n'ont pas été définies dans la classe doiventl'être en dehors

� Pour cela� chaque définition de méthode doit être précédée detemplate <typename T>

� ce qui précise que la définition dépend du type T� comme pour toute définition de méthode en dehors

de l'interface, il faut la faire précéder du nom de laclasse suivi de l'opérateur de résolution de portée :

� le nom de la classe est NomClasse <T>


UUCCLLBB

184

Exemple de méthodegénérique

Exemple de méthodeExemple de méthodegénériquegénérique

� Constructeur du modèle Tableau_Base

template <typename T>Tableau_Base<T> :: Tableau_Base (int nb) { if (nb<1) nb=1; taille=nb;

if ((tab = new T[taille])== 0) taille=0;

nb_elem=0; }


UUCCLLBB

185



� Définition de la méthode rechercher de la classegénérique Tableau_Trie� la méthode utilisée est la recherche dichotomique� le tableau peut contenir des doublons et on veut se

positionner sur le premier des doublons� la fonction générique proposée dans l'exemple

utilise les opérateurs relationnels < == et >� il faut donc que ces opérateurs soient définis pour

le type voulu afin que l'instanciation puisse seréaliser


UUCCLLBB

186



� template <typename T>T_CDRU Tableau_Trie<T>::rechercher(int &place, T elem) const{ int milieu, b_sup=nb_elem-1, b_inf=0, j; while (b_sup>=b_inf) { milieu=(b_sup+b_inf)/2; if (tab[milieu]>elem) b_sup=milieu-1; else if (tab[milieu]<elem) b_inf=milieu+1; else { // il faut remonter au premier des doublons for (j=milieu;j>=0 && tab[j]==elem;place=j,j--); return(T_TROUVE); } } place = b_inf; return(T_ABSENT);}


UUCCLLBB

187

Organisation d'un templateOrganisation d'un Organisation d'un templatetemplate

� L'instanciation d'un template est faite à lacompilation

� Il faut donc que le compilateur est accès au codedu template dans sa totalité

� C'est pourquoi un template est organisé en unseul fichier d'extension .h qui contient� la définition de la classe générique et

éventuellement des classes génériques dérivées� la définition de toutes les méthodes de ces classes

� REMARQUE: les templates de la STL sont décritsdans des headers sans l'extension .h


UUCCLLBB

188

Utilisation d'un templateUtilisation d'un Utilisation d'un templatetemplate

� Pour utiliser un template� il suffit d'inclure le header le décrivant� puis préciser au compilateur avec quel type il faut

instancier le modèle� exemple: déclaration d'un tableau trié de 10 chaînesTableau_Trie <Chaine> t1(10);

� on peut instancier un template avec un autre�//un arbre de listes d'entiersArbre <Liste <int> >;

�l'espace entre les 2 signes > est obligatoire, sinon il ya confusion possible avec l'opérateur >>


UUCCLLBB

189

La STLLa La STLSTL


UUCCLLBB

190

PrésentationPrésentationPrésentation

� La STL�Standard Template Library� bibliothèque de composants prédéfinis

�modèles, types et constantes�membres de l'espace de nom std�livrés sous forme de fichier d'en-tête inclus par#include <nom_en_tete> sans l'extension .h

� implémentent des structures de données classiquespermettant de définir des objets techniques


UUCCLLBB

191

PrésentationPrésentationPrésentation

� Les composants sont répartis en 5 catégories� les conteneurs: pour stocker d’autres objets.� les itérateurs : pour visiter les conteneurs� les algorithmes : procédures de traitement opérant

sur les différents conteneurs� les objet fonctions: classes qui redéfinissent

l’opérateur d’appel de fonction ()� les adaptateurs : encapsulation d’un autre

composant pour fournir une autre interface.� Seuls quelques composants sont présentés

partiellement ici


UUCCLLBB

192

Classe stringClasse Classe stringstring

� Cette classe ne fait pas partie réellement de laSTL, mais peut être vue comme un conteneur decaractères

� Pour l'utiliser il faut� inclure la description du modèle par <string>� introduire tous les identificateurs de l'espace de

noms std dans la région déclarative par usingnamespace std

� Pour connaître toutes les fonctionnalités de laclasse string voir la documentation en ligne


UUCCLLBB

193


� Exemple#include <string>using namespace std;

// essai de constructeursstringch1("hello"), // initialisation par une chaîne Cch2("essai",4), // initialisation avec les 4 premiers carch3(5,'*'), // initialisation avec 5 fois le car *ch4; // chaîne vide

x=ch1.length(); // longueur de la chaîne ch1cout<<ch1.at(0); // affiche le premier caractère de ch1cout<<ch1[0]; // idem


UUCCLLBB

194


� Exemple (suite)ch2.swap(ch3);// échange les contenus des chaînes ch2 et ch3

if (ch4.empty()) // teste si la chaîne ch4 est videif (ch4 == ch1) // opérateur d'égalité des contenus

ch4 = ch1 + ch2; // ch4 = concaténation de ch1 et ch2

pos = ch1.find('n',0);// pos contient la première position du caractère n dans la// chaine ch1 (0 pour la position en tête)

pos = ch1.rfind('a');// pos contient la dernière position du caractère a dans la// chaine ch1


UUCCLLBB

195


� Exemple (fin) // concaténation avec une chaine C-ANSI ch4 = ch4 + ".data";

// transformation d'un string en char *

char temp[26];

strcpy (temp,ch4.c_str());// attention c_str renvoie le pointeur uniquement// donc il faut ensuite recopier la zone par strcpy


UUCCLLBB

196

Classe iteratorClasse Classe iteratoriterator

� Les itérateurs représentent� un outil liés aux conteneurs� permettant d'exécuter des itérations sur les conteneurs� donc généralement définis comme classes internes des

conteneurs� Il existe différents types d'itérateur

� séquentiel unidirectionnel du début à la fin� séquentiel unidirectionnel de la fin au début� séquentiel bidirectionnel� à accès direct


UUCCLLBB

197

Classe iteratorClasse Classe iteratoriterator

� Un itérateur bidirectionnel peut être utilisé à laplace d'un unidirectionnel

� Un itérateur à accès direct peut remplacer unitérateur bidirectionnel

� Deux itérateurs de même type peuvent êtrecomparés

� L'opérateur * appliqué à un itérateur renvoie lavaleur de l'élément courant dans le conteneur quiutilise cet itérateur

� Les exemples sur les conteneurs utilisent desitérateurs


UUCCLLBB

198

Classe vectorClasse Classe vectorvector

� Cette classe définit un conteneur assez identiqueaux tableaux du C-ANSI� il s'agit d'une collection d'objets de même type� à laquelle on peut accéder par des itérateurs

séquentiel ou direct� Des méthodes permettent d'insérer ou de supprimer

des éléments dans le conteneur� Le modèle dispose aussi de l'opérateur [] pour un

accès direct aux éléments


UUCCLLBB

199


� Exemple (sous Visual C++)#include <iterator>#include <vector>using namespace std;

vector<int> v ; //declaration d'un vecteur d'entiers

//déclarations des iterateurs sur un conteneur vector<int>vector<int>::iterator it;

vector<int>::reverse_iterator it_r;

// remplissage du vecteur par la finfor (i=0; i<15 ; i++) v.push_back(i) ;

// affichage en visitant le conteneur du début à la finfor (it=v.begin() ;it != v.end() ; ++it) cout << * it <<" " ; // valeur de l'élément par *


UUCCLLBB

200


� Exemple (suite) // affichage en visitant le conteneur du début à la finfor (it=v.begin() ;it != v.end() ; ++it) cout << * it <<" " ; // valeur de l'élément par *

// affichage en visitant le conteneur dans le sens invsersefor (it_r=v.rbegin() ;it_r != v.rend(); ++it_r) cout << * it_r <<" " ;

x = v[i]; // accès direct à l'élément de rang i

//insertion de l'element 33 deux fois au rang de l'itérateurv.insert(it,2,33);

// suppression des elements du rang 1 au rang 3 (it+4 exclu)it=v.begin();v.erase(it+1,it+4);


UUCCLLBB

201


� Exemple (fin)cout << v.front(); // affichage de l'élément en tete

v.back(); // affichage de l'élément en fin

v.clear(); // nettoyage du tableau

if (v.empty()) // si tableau vide

nb_elt=v.size(); // nombre d'éléments dans le conteneur


UUCCLLBB

202

Classe listClasse Classe listlist

� Cette classe implémente un conteneur de typeliste doublement chaînée

null

front(tête)

back(fin)

null


UUCCLLBB

203


� Le modèle est décrit dans <list>� Les principales opérations fournies

� insertion d'éléments en tête, en queue mais aussi àun endroit quelconque

� suppression d'un élément en tête ou en queue� remplacement d'un élément dans la liste� tri, inversion d'une liste� élimination des doublons d'une liste� fusion entre deux listes triées


UUCCLLBB

204


� Exemple (sous Visual C++)#include <list>#include <iterator>#include <functional>#include <algorithm>using namespace std;

list <int> l ; // déclaration d'une liste d'entiers//déclarations des iterateurs sur un conteneur list<int>list<int>::iterator it;list<int>::reverse_iterator it_r;

for (i=0; i<15 ; i++) l.push_back(i) ; // on remplit la liste par la fin


UUCCLLBB

205


� Exemple (suite)// parcours par itérateurs et affichage de la liste lfor (it=l.begin() ;it != l.end() ; ++it) cout << *it <<" " ;for (it_r=l.rbegin() ;it_r != l.rend(); ++it_r) cout << *it_r <<" " ;

cout << l.size(); //nombre d'éléments dans la listel.insert(l.begin(),3,255); //insertion en tête de 255 (3 fois)

if (l.empty()) // teste si la liste l est vide

l.sort(); // tri de la liste lel.merge(l_bis); // fusion des listes l et l_bis dans ll.reverse(); // inversion de la liste ll.unique(); // élimination des doublons de la liste l


UUCCLLBB

206


� Exemple (fin)// recherche de l'élément = 15 grâce à l'algorithme find// si l'élément est absent alors it=l.end() et *it!=15it = find(l.begin(),l.end(),15);*it = 3615 // on remplace 15 par 3615

// recherche de 3615 grâce à l'algorithme find_if en utilisant// l'objet fonction bind1st avec la fonction equal_toit=find_if(l.begin(),l.end(),bind1st(equal_to<int>(),3615));*it=15; // on remet 15 à la place de 3615

l.erase(it1,it2); // détruit l'intervalle entre les itérateurs

cout << l.front(); // affiche l'élément en têtecout << l.back(); // affiche l'élément en finl.clear(); // nettoie la liste


UUCCLLBB

207

Classe dequeClasse Classe dequedeque

� Ce conteneur est une double queue� permettant des insertions et des suppressions en tête

et en fin de queue en temps constant quelle que soitla taille de la queue

� les insertions et les suppressions en milieu de laqueue sont de complexité linéaire

� il est particulièrement optimisé pour des ajouts et desretraits aux extrémités (cas des piles, file d'attente,etc)

� Le modèle est décrit dans <deque>


UUCCLLBB

208


� Exemple (sous Visual C++)#include <deque>#include <algorithm>#include <iostream>#include <iterator>using namespace std;

// définition dun conteneur deque d'entiers et des itérateursdeque<int> q, q_bis;deque<int>::iterator it;deque<int>::reverse_iterator it_r;

q.push_front(i); // empilage de l'entier i en têteq.push_back(i); // empilage de l'entier i en fincout << q.front(); // affichage de l'entier en têtecout << q.back(); // affichage de l'entier en fin


UUCCLLBB

209


� Exemple (suite)//affichage de la tête vers la finfor (it=q.begin() ;it != q.end() ; ++it)

cout << *it <<" " ;

// modification du troisième élément par l'opérateur [ ]q[2]=3615;

// suppression du troisième élémentit=q.begin() + 2; // positionnementq.erase(it); // effaçage

q.swap(q_bis); // q recopiée dans q_bis (q vide après)

if (q.empty()) // vrai si q vide

cout << q.size() // affiche le nombre d'éléments présentsq.clear() // nettoie la queue


UUCCLLBB

210


� Exemple (fin)// insertion de trois fois l'élément 255 en têteq.insert(q.begin(),3,255);

// vidage des 4 premiers éléments en tête de la queuefor (i=0;i<4;i++) { cout << q.front() <<"-"; // affichage élément en fin

q.pop_front(); // on enlève l'élément en tête}

// vidage des 3 premiers éléments en fin de la queuefor (i=0;i<3;i++) { cout << q.back() <<"-"; // affichage élément en début q.pop_back(); // on enlève l'élément en queue}


UUCCLLBB

211

Classe queueClasse Classe queuequeue

� class queue est un adaptateur de conteneur� c'est à dire qu'il est construit par dessus un autre

conteneur qui doit posséder les membres front,back, push_back et pop_front

� les conteneurs sous-jacents utilisés peuvent êtrelist ou deque mais pas vector

� cette classe permet d'implémenter le type abstraitfile d'attente (FIFO)

� Le modèle est décrit dans <queue>


UUCCLLBB

212

Classe queueClasse Classe queuequeue

� Exemple (sous Visual C++)#include <queue>#include <list>using namespace std;

//---declaration d'une queue d'entiers rqueue <int, list<int> > q; // construite à partir d'une liste

q.push(i); // place l'entier i dans la file (en fin)q.pop() // retire l'élément en tête de la filecout << q.front(); // affiche le premier élément entrécout << q.back(); // affiche le dernier lélément entré

if (q.empty()) // vrai si file videcout << q.size() // donne le nombre d'éléments dans la file


UUCCLLBB

213

Classe stackClasse Classe stackstack

� class stack est un adaptateur de conteneur� qui peut être construit à partir des conteneurs listdeque ou vector

� cette classe permet d'implémenter le type abstraitpile (LIFO)

� Le modèle est décrit dans <stack>


UUCCLLBB

214

Classe stackClasse Classe stackstack

� Exemple (sous Visual C++)#include <stack>#include <vector>using namespace std;

//---declaration d'une pile d'entiersstack <int, vector<int> > s; // construite à partir de vector

s.push(i); // empile ix=s.top() // on récupère le dernier élément empilés.pop(); // dépile le dernier élémentif (s==s_bis) // vrai si les 2 piles ont le même contenuif (s.empty()) // vrai si pile videcout << s.size() // donne le nombre d'éléments dans la pile


UUCCLLBB

215

Classe priority_queueClasse Classe prioritypriority_queue_queue

� class priority_queue est un adaptateur deconteneur� qui peut être construit à partir du conteneur deque� cette classe permet d'implémenter une file d'attente

avec priorité� en associant un ordre aux éléments en fonction de

la priorité� la priorité est en fait une relation d'ordre définie par

une fonction ou un objet fonction


UUCCLLBB

216

Classe priority_queueClasse Classe prioritypriority_queue_queue

� Exemple (sous HP-UX)#include <string>#include <queue>#include <deque>

//---declaration d'une file d'attente avec prioritépriority_queue<string, deque<string>, less<string> > q;

q.push(ch1) ; // stocke l'élément ch1q.top(); // récupère l'élément le plus prioritaireq.pop(); // rétire l'élément le plus prioritairecout << q.size() // donne le nombre d'éléments


UUCCLLBB

217

Classe mapClasse Classe mapmap

� Conteneur associatif� constitué à partir d'une paire clé, valeur� chaque clé est unique

� Les opérations ordinaires sont� insertion� suppression à partir d'une valeur de clé� recherche à partir d'une valeur de clé

� C'est le conteneur type pour implémenter unecollection d'objets comportant un identifiant


UUCCLLBB

218

Classe mapClasse Classe mapmap� Exemple

#include "Produit.h"#include <map>

Produit * Ptprod; // definition du type pointeur sur ProduitPtProd ptprod; // definition d'un pointeur PtProd

//--- conteneur de pointeurs sur Produits tries ---------// cle = numero produit de type string// donnee = un pointeur sur objet � de la hierarchie Produit

// definition du type SETPTPROD map de pointeurs PtProdtypedef map <string, PtProd, less<string>,allocator<PtProd> >

SETPTPROD;

typedef SETPTPROD::value_type value_type;

SETPTPROD setptprod; // instanciation du map


UUCCLLBB

219

Classe mapClasse Classe mapmap

� Exemple (suite)

//--- remplissage du conteneur ------------------------

for (i=0; i<3 ; i++) { cout <<"\n quel produit? 1-Perissable, 2-NonPerissable : "; cin >> rep; if (rep==1)

ptprod = new ProduitPerissable; else ptprod = new ProduitNonPerissable; cout << "\n entrez le produit a inserer : "; ptprod->saisie(); setptprod[ptprod->numprod()]=ptprod;}


UUCCLLBB

220

Classe mapClasse Classe mapmap� Exemple (fin)

SETPTPROD::iterator ite; // definition d'un iterateur

//--- affichage du conteneur selon l'ordre des cles--------for (ite = setptprod.begin(); ite!=setptprod.end(); ite++) (ite->second)->affiche();

//--- suppression d'un produit ----------------------------cout <<"\n entrer le numero du produit a supprimer: ";cin >> nprod;ite = setptprod.find(nprod); // recherche de l'elementif (ite == setptprod.end()) // echec

cout << "\nelement non trouve ";else

setptprod.erase(ite); // suppression du produit du conteneur

1

~ A. P. ~ Chapitre 5~ POO en C++ ~~ POO en C++ ~IUT A InformatiqueInformatique

UUCCLLBB

221

Traduction d'un modèle declasse

Traduction d'un modèle deTraduction d'un modèle declasseclasse

Chapitre V


UUCCLLBB

222

Les liens entre classes Les liens entre classes Les liens entre classes

2


UUCCLLBB

223

AssociationAssociationAssociation� Une association représente un lien sémantique

entre classes

� deux en général, parfois plus

� peut être réflexive

� définie par le sous-ensemble du produit cartésiendes ensembles cibles


UUCCLLBB

224

AgrégationAgrégationAgrégation� Forme d'association non symétrique

� exprime une relation composant/composé entre desclasses

� la classe composite est composée de plusieursclasses composantes

� les valeurs d'attributs des composants sepropagent vers celles d'attributs du composite

� Lorsque le cycle de vie des composants est lié àcelui du composite on parle de composition

3


UUCCLLBB

225

Agrégation vs héritageAgrégation Agrégation vsvs héritage héritage

� Ne pas confondre agrégation et héritage

� l'agrégation traduit un lien de type "a un"

� l'héritage traduit un lien de type "est un"

� La composition est une forme particulièred'agrégation


UUCCLLBB

226

Modélisation UML - ClasseModélisation UML - ClasseModélisation UML - Classe

créer()

afficher()

supprimer()

#couleur

#race

Chat Nom de la classe

Liste des attributs

Liste des méthodes

+ public

# protégé

- privé{

4


UUCCLLBB

227

Modélisation UML - ObjetModélisation UML - ObjetModélisation UML - Objet

Objet Mistigri de la classe ChatMistigri:Chat

Objet anonyme:Chat


UUCCLLBB

228

Modélisation UML - MessageModélisation UML - MessageModélisation UML - Message

:Objet1

message:Objet2

donnéemessage

5


UUCCLLBB

229

Modélisation UML - AssociationModélisation UML - AssociationModélisation UML - Association

visite1

Représentant Client

1..*

constituée de*

Commande Produit

1..*

ligne commande

quantité


UUCCLLBB

230

Modélisation UML - AgrégationModélisation UML - AgrégationModélisation UML - Agrégation

comprend

0..*

Portefeuille Type_placement

1..*

Portefeuille est formé de Type_placement

Type_placement n'existe pas sans Portefeuille

6


UUCCLLBB

231

Modélisation UML - CompositionModélisation UML - CompositionModélisation UML - Composition

0..1

Document

En-tête Corps

1..1

Un document a un ou aucun en-tête et a un corps


UUCCLLBB

232

Modélisation UML - HéritageModélisation UML - HéritageModélisation UML - Héritage

Produit

Produit Périssable Produit Non périssable

super classe

sous classe

Un produit périssableest un produit

Un produit non périssableest un produit

7


UUCCLLBB

233

Traduction des liensTraduction des liensTraduction des liens


UUCCLLBB

234

RèglesRèglesRègles

� Une classe du modèle conceptuel est décrite parune classe au niveau physique

� La traduction d'une association du modèleconceptuel dépend des cardinalités du lien c'est àdire de la multiplicité des rôles de l'association

8


UUCCLLBB

235

Cas des associationsCas des associationsCas des associations� Une association du modèle conceptuel est

traduite par

� un lien de référence entre classe de départ et laclasse d'arrivée pour une cardinalité de type unseul

� un ensemble de liens dans un conteneur pour lescardinalités de type un à plusieurs

� une classe associative si la relation est porteuse dedonnées ou le lien de cardinalité de type plusieursà plusieurs

Pose le problème du lienPose le problème du lien


UUCCLLBB

236

Problème des associationsProblème des associationsProblème des associations

� Au niveau conceptuel les associations sontsymétriques

� Or un lien au niveau physique est antisymétrique� orienter le lien dans un sens ou dans l'autre

suivant les besoins de navigation� ou définir un lien et un lien inverse si il faut pouvoir

naviguer dans les deux sens

9


UUCCLLBB

237

Implantation d'un lienImplantation d'un lienImplantation d'un lien

� Lien "par référence"� le lien est un pointeur sur l'objet lié� le cycle de vie des objets reliés n'est pas lié� la signification du pointeur dépend du contexte

d'exécution

� Lien "par valeur"� correspond à un attribut du type de l'objet lié� le cycle de vie des objets est lié� notion de clé


UUCCLLBB

238

Liens et persistanceLiens et persistanceLiens et persistance

� La persistance désigne la propriété qu'a un objetà perdurer au delà du programme qui l'a créé

� Comment assurer la persistance ?�méthode de sauvegarde/restauration dans la classe� si la sauvegarde se fait dans un SGBD-R, en

principe une classe = une table de tuples� et les liens vers d'autres objets sont traduits par

des clés étrangères

Il faut traduire les liens dans les objetspar une collection de clés étrangèresIl faut traduire les liens dans les objetspar une collection de clés étrangères

10


UUCCLLBB

239

Liens et persistanceLiens et persistanceLiens et persistance

� si la sauvegarde se fait dans un SGBD-OR, enprincipe une classe = un TAD

� sauvegarde dans un table d'objets

� le méthodes peuvent invoquées depuis le clienten mode SQL

� et les liens vers d'autres objets sont traduits pardes OID


UUCCLLBB

240

Persistance et héritagePersistance et héritagePersistance et héritage

� Plusieurs solutions pour l'héritage

� dans les SGBD-R�une table pour la super-classe et une table pour

chaque sous-classe�ou une table qui regroupe l'ensemble de la hiérarchie

� dans les SGBD-OR, même principe mais avec desTAD et des sous-TAD

Documents

Programmation Objet en C++ - olazo.free.frolazo.free.fr/IUT/Cours/cours c++ objet.pdf · IUT A Informatique ~ POO en C++ ~ Chapitre 1 UC LB 26 ObjetObjet Un objet est une entité