La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

420-KAB-LG Programmation orientée par objets 1 Chapitre 1 Introduction à la POO: –Les classes vs les objets.

Présentations similaires


Présentation au sujet: "420-KAB-LG Programmation orientée par objets 1 Chapitre 1 Introduction à la POO: –Les classes vs les objets."— Transcription de la présentation:

1 420-KAB-LG Programmation orientée par objets 1 Chapitre 1 Introduction à la POO: –Les classes vs les objets

2 420-KAB-LG Programmation orientée par objets 2 Programmation procédurale ou orientée par objets? La programmation procédurale: La programmation orientée par objets: Tas de données Méthode 1 Méthode 2 Méthode 3 Méthode 4 Méthode 5 Méthode 6 Données Méthode 1 Méthode 2 Méthode 3 Méthode 4 Méthode 5 Méthode 6

3 420-KAB-LG Programmation orientée par objets 3 Avantages de la POO Pour le programmeur: –Permet de rassembler des données qui vont logiquement ensemble afin de les traiter comme un tout. –Protège les données en limitant le traitement à ce qui est prévu par lobjet uniquement. De façon plus générale: –Elle augmente lintelligibilité des programmes en rassemblant les données et les traitements qui sappliquent à elles. –Elle facilite la réutilisation de morceaux de programmes. –Elle facilite la mise à jour et lajout de fonctionnalités.

4 420-KAB-LG Programmation orientée par objets 4 Un objet... Définition: « Chose solide ayant unité et indépendance. » Dans le contexte informatique un objet peut représenter: –Un objet concret : une chaise, un bureau, une personne... –Un objet abstrait: un compte de banque, un cours de programmation… Un objet se compare à une variable: il doit être déclaré avant dêtre utilisé et a une durée de vie.

5 420-KAB-LG Programmation orientée par objets 5 Une classe... Définition: « Idée abstraite servant à modéliser un ensemble dobjets concrets. » Une classe se compare à un type. Lexistence dun type ne représente rien tant quon na pas déclaré une variable. La classe nest quun moule servant à créer des objets. Un objet est aussi nommé une instance dune classe. Une classe possède des membres: –Attributs: variables qui représentent les données de lobjet. Les valeurs de ces données sont les états de lobjet. Chaque objet a un ensemble dattributs (de variables) qui lui est propre. –Méthodes: actions qui sappliquent à lobjet ou encore services que peut rendre lobjet. On déclare des objets dune classe tout comme on déclare des variables dun certain type. La classe est une extension de la notion de structure...

6 420-KAB-LG Programmation orientée par objets 6 Attributs ou propriétés Définition: « Une caractéristique ou un état que possède tous les objets dune même classe mais dont le contenu peut varier dun objet à lautre. »

7 420-KAB-LG Programmation orientée par objets 7 Méthodes Définition: « Une méthode est un sous- programme qui appartient à une classe et effectue un traitement sur les attributs de cette classe ». Une méthode peut servir à: –Modifier la valeur dun attribut (setter) –Obtenir la valeur dun attribut (getter) –Effectuer un traitement plus général

8 420-KAB-LG Programmation orientée par objets 8 Les modificateurs daccès public: –Le membre est visible à lintérieur de la classe comme de lextérieur (interface). private: –Le membre nest visible quà lintérieur de la classe (encapsulation). La seule différence entre une classe et une structure est laccès par défaut (si non spécifié): –Pour une classe: private –Pour une structure: public (rétrocompatibilité) protected: –Le membre nest visible quà lintérieur de la classe et ses dérivées (dans le contexte de lhéritage)

9 420-KAB-LG Programmation orientée par objets 9 Représentation UML dune classe Accès: - Privé + Publique # Protégé Méthodes Attributs Nom

10 Conception dune classe... Une classe a des méthodes et des attributs (on peut faire la distinction entre un attribut fixe (caractéristique) ou variable (état)) La classe se protège et assure sa cohérence interne! La classe fournie une interface simple (des méthodes publiques) mais complète! Un attribut est toujours privé! Accès à un attribut: Aucun Lecture seule (getter) Lecture et écriture (getter et setter) 420-KAB-LG Programmation orientée par objets 10

11 420-KAB-LG Programmation orientée par objets 11 Trois grands principes de la POO

12 420-KAB-LG Programmation orientée par objets Lencapsulation Définition: « Exposer les fonctionnalités dun objet tout en cachant les structures de données et les détails dimplémentation. » Indépendance: –Afin dassurer la cohérence interne dun objet, seul ce dernier doit pouvoir lire et modifier ses attributs. Les attributs devraient donc toujours être privés! –Les méthodes publiques implémentent linterface dutilisation. Elle doit être simple mais complète. Elle doit aussi assurer la cohérence. Unité: –Il existe un lien cohérent entre les attributs. –Les méthodes doivent lire et/ou modifier les attributs.

13 420-KAB-LG Programmation orientée par objets Lhéritage Permet la généralisation: cest une caractéristique importante dun langage naturel! Simplifie les programmes en évitant la redondance.

14 420-KAB-LG Programmation orientée par objets Le polymorphisme Définition: « Le polymorphisme consiste à faire abstraction de la forme. » Prendre lautomobile Prendre lautobus Méthode abstraite

15 420-KAB-LG Programmation orientée par objets 15 Un exemple en C++ class CBicyclette { public: void Freiner(); void Pedaler(); string ObtenirCouleur(); void ModifierCouleur(string couleur); private: string Couleur_; float Vitesse_; int Hauteur_; };

16 420-KAB-LG Programmation orientée par objets 16 Écriture dune classe Déclaration dans le.h: class CEntierEncapsule { int Entier_; public: void SetEntier(int NouvelEntier); int GetEntier() const; }; Définition dans le.cpp: void CEntierEncapsule::SetEntier(int NouvelEntier) { Entier_ = NouvelEntier; } Utilisation: int main() { CEntierEncapsule UnObjet; UnObjet.SetEntier( 10 ); cout << UnObjet.GetEntier(); }

17 420-KAB-LG Programmation orientée par objets 17 Procédurale VS Objets class CPersonne { public: int Age; bool EstAdulte() { return Age >=18; } }; int main() { CPersonne Joan; Joan.Age = 19; cout << Joan.EstAdulte(); } bool EstAdulte(int Param) { return Param>= 18; } int main() { int Age; Age= 19; cout << EstAdulte(Age); }

18 Les méthodes constantes Le mot-clé const après la déclaration dune méthode garantit que cette méthode ne modifiera aucun des attributs de la classe. Cest une protection pour le programmeur. Cest une excellente pratique que de déclarer les accesseurs const (ainsi que toute autre méthode qui na pas besoin de modifier les attributs de lobjet). 420-KAB-LG Programmation orientée par objets 18 Exemple: int GetEntier() const;

19 Vers la POO: Avant float Quotient(int Num, int Den) { float q =0.0f; if(Den!=0) q = (float)Num / (float)Den; return q; } int main() { int n=3; int d=4; cout << Quotient(3,4) << endl; } 420-KAB-LG Programmation orientée par objets 19 Ancienne façon de faire un cast

20 Vers la POO: Naissance struct Fraction { int Num; int Den; }; float Quotient(Fraction Fr) { float q = 0.0f; if(Fr.Den!=0) q = static_cast (Fr.Num) / static_cast (Fr.Den) ; return q; } int main() { Fraction Frac; Frac.Num = 3; Frac.Den = 4; cout << Quotient(Frac) << endl; } 420-KAB-LG Programmation orientée par objets 20 Apparition dun nouveau concept et regroupement des données

21 Vers la POO: Intégration class Fraction { public: int Num; int Den; float Quotient() { float q = 0.0f; if(Den!=0) q = static_cast (Num) / static_cast (Den); return q; } }; int main() { Fraction Frac; Frac.Num = 3; Frac.Den = 4; cout << Frac.Quotient() << endl; } 420-KAB-LG Programmation orientée par objets 21 Ajout de la méthode à la classe: Regroupement des données et des méthodes qui utilisent ces données

22 Ce quil faut retenir... Il faut bien comprendre les structures (ref. KA0) pour apprendre la POO. À partir de maintenant nous ajouterons des fonctions à nos structures! Nous utiliserons le mot-clé class au lieu de struct mais il y a peu de différences pour le compilateur 420-KAB-LG Programmation orientée par objets 22

23 420-KAB-LG Programmation orientée par objets 23 Chapitre 2 Le cycle de vie

24 420-KAB-LG Programmation orientée par objets 24 Les services par défaut dune classe 1. La construction –Allocation de la mémoire –Attributs non-initialisés 2. La construction dune copie –Allocation de la mémoire –Copie membre à membre (shallow copy) 3. Laffectation entre objets dune même classe –Copie membre à membre (shallow copy) 4. La destruction –Libération de la mémoire Les services par défaut peuvent être redéfinis!

25 Exemple // Fichier EntierEncapsule.h class CEntierEncapsule { public: int GetEntier() const; void SetEntier(int Entier); private: int Entier_; }; 420-KAB-LG Programmation orientée par objets 25

26 Exemple (suite) int main() { CEntierEncapsule Entier1, // Construction par défaut Entier2; Entier1.SetEntier(10); AfficherObjet(Entier1); Entier2 = Entier1; // Affectation dun objet à un autre AfficherObjet(Entier2); system("Pause"); }// Destruction des objets void AfficherObjet(CEntierEncapsule EntierEncapsule) // Construction dune copie { cout << EntierEncapsule.GetEntier() << endl; }// Destruction de lobjet // passé en paramètre 420-KAB-LG Programmation orientée par objets 26

27 Les services par défaut (suite) Parfois le service par défaut ne suffit pas! –Par exemple, la construction par défaut ninitialise pas les attributs! Nous pouvons implémenter nous-mêmes la construction dun objet, la copie, laffectation et la destruction dun objet. 420-KAB-LG Programmation orientée par objets 27

28 Les services par défaut (suite) La déclaration dun constructeur permet dinitialiser lobjet après lallocation de lobjet. La déclaration dun constructeur de copie dans une classe remplace le constructeur de copie par défaut. La déclaration dun destructeur dans une classe permet de faire le ménage avant la libération de lobjet. La surcharge de lopérateur = remplace le service par défaut daffectation. 420-KAB-LG Programmation orientée par objets 28

29 420-KAB-LG Programmation orientée par objets 29 Le constructeur Quaffiche à lécran le programme suivant? int main() { CEntierEncapsule UnObjet; cout << UnObjet.GetEntier() << endl; } Une valeur aléatoire car la construction par défaut ninitialise pas les attributs! (comme au laboratoire!)

30 420-KAB-LG Programmation orientée par objets 30 Le constructeur (suite) Il faudrait plutôt faire: int main() { CEntierEncapsule UnObjet; UnObjet.SetEntier(20); cout << UnObjet.GetEntier() << endl; } Cela ne devrait pas être la responsabilité de lutilisateur de la classe dinitialiser lobjet, mais à lobjet lui-même de sinitialiser correctement!

31 420-KAB-LG Programmation orientée par objets 31 Le constructeur (suite) Lors de la construction dun objet, le compilateur invoque automatiquement une méthode qui se charge de linitialisation de lobjet. Cette méthode spéciale se nomme un constructeur. Doit initialiser tous les attributs et exécuter toutes autres instructions requises pour initialiser lobjet. Na pas de valeur de retour (même pas void!) Porte le même nom que la classe. Peut avoir des paramètres ou non. On peut définir plusieurs constructeurs pour une même classe, mais ils doivent avoir des signatures différentes.

32 420-KAB-LG Programmation orientée par objets 32 Le constructeur sans paramètres Il est unique! Exemple: class CEntierEncapsule { public: CEntierEncapsule(); // Même nom que la classe // pas de type de retour! }; CEntierEncapsule::CEntierEncapsule() // Définition { Entier_ = 0; // ou encore mieux SetEntier(0); }

33 420-KAB-LG Programmation orientée par objets 33 Le constructeur sans paramètre (suite) Et maintenant, quaffiche à lécran le programme suivant? int main() { CEntierEncapsule UnObjet; cout << UnObjet.GetEntier() << endl; } Il affiche 0 ! Nest-ce pas génial?? Appel automatique du constructeur sans paramètre

34 420-KAB-LG Programmation orientée par objets 34 Les constructeurs avec paramètre(s) Exemple: class CEntierEncapsule { public: CEntierEncapsule(int Valeur); // Même nom que la classe // pas de type de retour! }; // un paramètre int CEntierEncapsule::CEntierEncapsule(int Valeur) { Entier_ = Valeur; //ou encore mieux SetEntier(Valeur); }

35 420-KAB-LG Programmation orientée par objets 35 Les constructeurs avec paramètres (suite) int main() { CEntierEncapsule UnObjet(99); cout << UnObjet.GetEntier() << endl; } Il affiche 99 ! Appel automatique du constructeur qui prend un int

36 420-KAB-LG Programmation orientée par objets 36 La valeur par défaut dun paramètre En C++, un paramètre peut avoir une valeur par défaut. La valeur est définie dans le prototype seulement (.h). Si le paramètre nest pas spécifié lors de lappel, la valeur par défaut est utilisée. Exemple: void Afficher(string Message="Bonjour", int Fois = 1); Peut être appelé de trois façons: Afficher("Salut", 5); // Affiche Salut 5 fois Afficher("Allo");// Affiche Allo 1 fois Afficher();// Affiche Bonjour 1 fois Par contre, Afficher(5) donne une erreur de compilation…

37 420-KAB-LG Programmation orientée par objets 37 La valeur par défaut et les constructeurs On peut donc remplacer plusieurs constructeurs par un seul constructeur avec des paramètres avec des valeurs par défaut! Évite la redondance du code. Exemple: class CPersonne { public: CPersonne(string Nom="Roger", int Age=20); // remplace avantageusement: // CPersonne(); // CPersonne(string Nom); // CPersonne(string Nom, int Age); };

38 420-KAB-LG Programmation orientée par objets 38 Le constructeur de copie Appelé de façon implicite lorsque: 1. Un objet est passé en tant que paramètre par valeur 2. Un objet est retourné par une fonction 3. Un objet est construit à partir dun autre objet Son rôle est de créer une copie exacte de lobjet passé en paramètre Sa signature est toujours la même: – NomClasse (const NomClasse& Original);

39 420-KAB-LG Programmation orientée par objets 39 Le constructeur de copie class CEntierEncapsule { public: CEntierEncapsule(const CEntierEncapsule& Original); }; CEntierEncapsule::CEntierEncapsule(const CEntierEncapsule& Original) { Entier_ = Original.GetEntier(); // ou encore mieux: SetEntier(Original.GetEntier() ); } Pourquoi un passage par référence??

40 Si le constructeur de copie utilisait un passage par valeur… int main() { A a; A b(a); } class A { public: A(const A p); }; 420-KAB-LG Programmation orientée par objets 40 Appel de b.CtrCopie(a) Appel de p.CtrCopie(a)

41 Les paramètres constants Un paramètre déclaré const indique quil ne pourra pas être modifié à lintérieur de la méthode. On peut aussi déclarer un objet local constant. Sur les objets et les paramètres const, on ne peut appeler que des méthodes const, pour respecter la garantie! Exemple: CEntierEncapsule::CEntierEncapsule(const CEntierEncapsule& Original) 420-KAB-LG Programmation orientée par objets 41

42 Le const est un virus… class CRect { int x_,y_; public: CRect(const CRect& Autre); void GetX() ; void GetY() ; }; CRect::CRect(const CRect& Autre) { x_ = Autre.GetX(); } 420-KAB-LG Programmation orientée par objets 42 Erreur: impossible de convertir un pointeur 'this' de 'const CRect&' en CRect&' const

43 420-KAB-LG Programmation orientée par objets 43 Le destructeur Na pas de valeur de retour A le même nom que la classe préfixé du symbole ~ Effectue les instructions appropriées lorsque lobjet est détruit –Fermeture dun fichier –Destruction de mémoire allouée dynamiquement Pour linstant, le service par défaut fera laffaire!

44 Le destructeur (suite) class CEntierEncapsule { public: ~CEntierEncapsule(); }; CEntierEncapsule::~CEntierEncapsule() { cout << "Rien à faire pour linstant…" << endl; } int main() { CEntierEncapsule UnObjet(99); cout << UnObjet.GetEntier() << endl; } 420-KAB-LG Programmation orientée par objets 44 Appel automatique du destructeur!

45 Les caprices des constructeurs Dès quau moins un constructeur est défini, le service de construction par défaut disparait! Un constructeur sans paramètre est souvent essentiel (tableaux, composition, héritage, etc.) Attention de ne pas créer des situations ambiguës: class CPasClair { CPasClair(); CPasClair(int i=3); }; int main() { CPasClair a; // error C2668: 'CPasClair::CPasClair' : // appel ambigu à une fonction surchargée } 420-KAB-LG Programmation orientée par objets 45

46 420-KAB-LG Programmation orientée par objets 46 Chapitre 3 Les relations

47 Diagramme de classes UML 420-KAB-LG Programmation orientée par objets 47

48 Relations entre les classes Il existe plusieurs types de relations entre deux classes: –Aucune relation Classes complètement indépendantes –Utilisation Simple dépendance: paramètre, variable locale ou valeur de retour 420-KAB-LG Programmation orientée par objets 48

49 Relations entre les classes (suite) –Composition –Agrégation –Héritage 420-KAB-LG Programmation orientée par objets 49

50 La relation crée une dépendance La classe A qui a une relation avec la classe B devient dépendante de cette dernière Une classe dépendante dune autre classe fait des #include « B.h » La modification dune classe – provoque normalement la recompilation des classes dépendantes (erreurs?) –Peut amener un mauvais fonctionnement des classes dépendantes 420-KAB-LG Programmation orientée par objets 50

51 Première relation: Lutilisation 420-KAB-LG Programmation orientée par objets 51

52 Lutilisation Une classe peut utiliser une autre classe de trois façons: –En paramètre dune méthode –En variable locale dans une méthode –En valeur de retour dune méthode 420-KAB-LG Programmation orientée par objets 52

53 …en paramètre type A::Methode(B b) type A::Methode(B& b) type A::Methode(const B& b) Exemples: bool CBanque::Bloquer(Compte c); void CConsole:: Afficher(const string& Message); void CFenetre::Afficher (CImage& Image, int x, int y); 420-KAB-LG Programmation orientée par objets 53

54 … en variable locale type A::Methode() { B b; } bool CResto::Payer(float Montant) { CFacture Facture(Montant); Facture.Imprimer(); //… } 420-KAB-LG Programmation orientée par objets 54

55 … en valeur de retour B A::Methode() { B b; // … return b; } Exemple: COeuf CPoule::Pondre() { COeuf UnOeuf; // … return UnOeuf; } 420-KAB-LG Programmation orientée par objets 55

56 Deuxième relation: La composition 420-KAB-LG Programmation orientée par objets 56

57 420-KAB-LG Programmation orientée par objets 57 Mise en contexte (CAuto) class CAuto { public: CAuto(); ~CAuto(); int GetNbChevaux() const; void SetNbChevaux(int NbChevaux); void DegonflerUneRoue(int i); private: int NbChevauxDuMoteur_; int PressionDesRoues_[4]; };

58 Classes CRoue et CMoteur 420-KAB-LG Programmation orientée par objets 58 CRoue -Pression_:int +Dégonfler() CMoteur -NbChevaux_:int +GetNbChevaux():int +SetNbChevaux(entrée NbChevaux:int)

59 Classe CAuto améliorée 420-KAB-LG Programmation orientée par objets 59 class CAuto { public: CAuto(); ~CAuto(); CRoue& GetRoue(int Index); void Modifier(int NbChevaux); private: CMoteur& GetMoteur(); CMoteur SuperMoteur_; CRoue Roues_[4]; };

60 La composition La composition est un type de relation entre deux classes qui implique une notion de contenance. On dit que A et B sont deux classes reliées par une relation de composition, cest-à-dire que A est composée de B A = Composée ; B= Composant 420-KAB-LG Programmation orientée par objets 60

61 La composition Exemples: Un objet Auto se compose dobjets moteur et roues. Un objet Hôtel se compose dobjets ChambreHôtel Un objet Ordinateur se compose dobjets CPU, clavier et écran Un objet mammifère se compose dobjets tête, 4 pattes KAB-LG Programmation orientée par objets

62 La composition Le composant est utilisé comme attribut du composé. Les cycles de vie du composé et ses composants sont intimement liés. Il sagit dune agréagation forte: si le composé est détruit, ses composants disparaissent aussi KAB-LG Programmation orientée par objets

63 Construction / destruction dune composition Si un objet B est un attribut de lobjet A, le constructeur de lobjet B sera appelé avant celui de lobjet A. Ceci est logique: pour construire une auto, il faut dabord construire ses composantes, comme le moteur et les roues. 420-KAB-LG Programmation orientée par objets 63 Raison: Accès possible

64 Construction / destruction dune composition Lors de la destruction cest linverse Si on veut utiliser un autre constructeur que le constructeur par défaut (ou mixte), on peut sélectionner le constructeur à utiliser lors de la pré-construction KAB-LG Programmation orientée par objets

65 La pré-construction CAuto::CAuto() : SuperMoteur_(90) { cout << "Constructeur de CAuto" << endl; } On peut même utiliser cette syntaxe pour initialiser tous les attributs : CChat::CChat(int Age, string Nom) : Age_(Age), Nom_(Nom) { } 420-KAB-LG Programmation orientée par objets 65

66 Agrégation forte vs faible 420-KAB-LG Programmation orientée par objets 66 Agrégation forte = Composition Agrégation faible : Le composant ne disparaît pas si le composé est détruit. Exemples: (Aéroport et avions), (Train et wagons), (groupe et étudiants), (Ferme et animaux)

67 Représentation UML de la composition 420-KAB-LG Programmation orientée par objets 67

68 Lencapsulation appliquée à la composition class CAuto { public: CAuto(); ~CAuto(); const CRoue& GetRoue(int Index); void Modifier(int NbChevaux); private: CMoteur& GetMoteur(); CMoteur SuperMoteur_; CRoue Roues_[NBROUES]; }; 420-KAB-LG Programmation orientée par objets 68 Pas daccès direct au moteur Laccès à une roue est en lecture seule

69 420-KAB-LG Programmation orientée par objets 69 Exécution du programme Auto

70 Troisième relation: Lhéritage ( 2 e grand principe de la POO) 420-KAB-LG Programmation orientée par objets 70

71 Motivation 420-KAB-LG Programmation orientée par objets 71

72 Généralisation 420-KAB-LG Programmation orientée par objets 72 Classe de base, parent ou générale Classes dérivées, enfants ou spécialisées Dérive de... Hérite de... Est une... Is a… Dérive de... Hérite de... Est une... Is a…

73 LHéritage Lhéritage offre la possibilité de créer une classe à partir dune autre. La nouvelle classe bénéficie des attributs et des méthodes de la classe dont elle dérive. On dira alors que la classe enfant hérite du parent ou que la classe dérivée hérite de la classe de base. Dans la classe dérivée, on peut définir de nouveaux membres afin de modifier et de spécialiser la classe de base. 420-KAB-LG Programmation orientée par objets 73

74 Déclaration de CPersonne class CPersonne { int Age_; public: CPersonne(int Age); ~CPersonne(); int GetAge() const; void SeDéplacer(); }; 420-KAB-LG Programmation orientée par objets 74 Classe normale, rien ne change!

75 Déclaration de CEtudiant class CEtudiant : public CPersonne { int Note_; public: CEtudiant(int Age, int Note); ~CEtudiant(); int GetNote() const; void Etudier(); }; 420-KAB-LG Programmation orientée par objets 75 Indique que la classe dérive de CPersonne

76 Déclaration de Enseignant class CEnseignant : public CPersonne { int Salaire_; public: CEnseignant(int Age, int Salaire); ~CEnseignant(); int GetSalaire() const; void Enseigner(); }; 420-KAB-LG Programmation orientée par objets 76 Indique que la classe dérive de CPersonne

77 Exemple dutilisation int main() { CEtudiant Paul(19, 85); Paul.Etudier(); cout << Paul.GetNote(); Paul.SetDéplacer(); cout << Paul.GetAge(); CEnseignant Joan(35, 15000); Joan.Enseigner(); cout << Joan.GetSalaire(); Joan.SeDéplacer(); cout << Joan.GetAge(); } 420-KAB-LG Programmation orientée par objets 77 Méthodes héritées de la classe parent

78 Les modificateurs daccès Les membres publics dune classe sont utilisables par toutes les fonctions. Les membres privés dune classe sont utilisables uniquement par les fonctions membres de cette classe. Les membres protégés dune classe sont utilisables par les fonctions membres de cette classe ou dune classe dérivée. 420-KAB-LG Programmation orientée par objets 78

79 420-KAB-LG Programmation orientée par objets 79

80 Construction et destruction Lors de la création dun objet de la classe Etudiant, il y a deux constructeurs impliqués. Lorsquun objet Etudiant est détruit, il y a deux destructeurs qui participent à la destruction de lobjet. 1. Quel est lordre dappel des constructeurs et des destructeurs? 2. Comment faire pour déterminer cet ordre? 3. Pourquoi cet ordre précis? 420-KAB-LG Programmation orientée par objets 80

81 La pré-construction Lors de la pré-construction, on peut sélectionner le constructeur de la classe de base à utiliser pour acheminer de linformation à la classe de base: CEtudiant::CEtudiant(int Age, int Note): CPersonne(Age) { SetNote(Note); } La pré-construction peut aussi servir à sélectionner les constructeurs à utiliser lors de la construction dun composé. 420-KAB-LG Programmation orientée par objets 81

82 420-KAB-LG Programmation orientée par objets 82 Chapitre 4 Pointeurs, allocation dynamique et références 82

83 420-KAB-LG Programmation orientée par objets 83 Programmation orientée par objets Les pointeurs 0x20 0x x20 83

84 Les adresses 420-KAB-LG Programmation orientée par objets 84 On accède à ladresse dune variable (sa position en mémoire) avec le symbole & On accède au contenu dune adresse avec le symbole * int main() { int a = 3; cout << a; // Affiche 3 cout << &a; // Affiche 0068FDF4 cout << *(&a); // Affiche 3, *(&a) = a } La variable a peut être de type primitif (int, char, …) ou un objet

85 Les pointeurs Un pointeur contient et permet de manipuler ladresse dune variable ou dun objet. Déclaration dun pointeur: int *p; // Pointeur vers un int CEntier *pEntier; // Pointeur vers un CEntier short a, *b; // a est un short, b est // pointeur vers un short 420-KAB-LG Programmation orientée par objets 85

86 Exemple dutilisation dun pointeur (1) short a, *b; *a = 5; // invalide: a nest pas un pointeur b = &a; // valide: b est un pointeur de // short, et &a est l'adresse d'un // short *b = 5; // valide: b est un pointeur de // short. Cette opération a pour // effet de déposer la valeur 5 // là où pointe b... donc dans a 420-KAB-LG Programmation orientée par objets 86

87 Exemple dutilisation dun pointeur (2) int main () { int a, // valeur de a: indéterminée b= 3; // valeur de b: 3 int *p; // p est un pointeur vers un int p= &a; // p ladresse de a; p pointe // vers a *p= 4; // le contenu pointé par p ( donc // a ) reçoit 4 b+= a; // b devient égal à 7! } 420-KAB-LG Programmation orientée par objets 87

88 Visualiser les pointeurs int a, b= 3; int *p; p= &a; *p= 4; 420-KAB-LG Programmation orientée par objets 88

89 Initialiser un pointeur int *p = 0; // (…) if (p != 0) { //... p mène à un endroit valide } else { //... utiliser *p serait imprudent!... } 420-KAB-LG Programmation orientée par objets 89 En C, on utilisait la constante NULL, en C++ on utilise ladresse 0 (zéro)

90 Pointeurs et POO CEntier UnEntier(4) // Affiche 4 cout << UnEntier.GetEntier(); // Affiche 0072AB00 cout << &UnEntier; // Affiche 4 cout << (*(&UnEntier)).GetEntier(); 420-KAB-LG Programmation orientée par objets 90

91 Pointeurs et POO (suite) // Déclaration dun pointeur vers un // objet CEntier *pEntier = 0; // Allocation dynamique dun objet pEntier = new CEntier(3); // Appel des méthodes de lobjet pointé // par pEntier (*pEntier).SetEntier(3); cout << (*pEntier).GetEntier() << endl; 420-KAB-LG Programmation orientée par objets 91

92 Lopérateur -> Lopérateur -> est une syntaxe abrégée qui permet de sélectionner un membre dun objet pointé par un pointeur: (*pEntier).SetEntier(3); est identique à pEntier->SetEntier(3); 420-KAB-LG Programmation orientée par objets 92

93 Passer un pointeur en paramètre void Afficher(CEntier* pEntier) { cout GetEntier(); } int main() { CEntier Entier(3); CEntier *pEntier = new CEntier(4); Afficher(&Entier); Afficher(pEntier); } 420-KAB-LG Programmation orientée par objets 93

94 Passer un pointeur en paramètre (suite) Très similaire au passage par référence Il ny a pas de copie dobjets effectués Les modifications apportées à lobjet dans la méthode ou la fonction se répercuteront à lextérieur de la méthode ou de la fonction. Cependant, contrairement à la référence, un pointeur peut être nul ou invalide. 420-KAB-LG Programmation orientée par objets 94

95 Retourner un pointeur CEntier* Creer(int iValeur) { return new CEntier(iValeur); } int main() { CEntier *pEntier = Creer(5); cout GetEntier(); } 420-KAB-LG Programmation orientée par objets 95

96 Erreur à ne jamais faire! (1) CEntier* Creer(int Valeur) { CEntier EntierLocal(Valeur); return &EntierLocal; } int main() { CEntier *pEntier = Creer(5); cout GetEntier(); } 420-KAB-LG Programmation orientée par objets 96

97 Détruire un objet créé dynamiquement int main() { CEntier *pEntier = new CEntier(6); cout GetEntier(); // … delete pEntier; } Il est de bon usage que celui qui créé un objet soit responsable de le détruire. 420-KAB-LG Programmation orientée par objets 97

98 Erreur à ne jamais faire! (2) CEntier Entier(3); CEntier *pEntier = 0; CEntier *pEntier2 = 0; pEntier = &Entier; pEntier2 = pEntier; delete pEntier; delete pEntier2; 420-KAB-LG Programmation orientée par objets 98

99 Pile vs Tas 420-KAB-LG Programmation orientée par objets 99 Pile int main() { int i = 2; CEtudiant *p = 0; p = new CEtudiant(); test(i); delete p; } void test(int j) { cout << j; } Tas 2 (i) 0 (p) CEtudiant 2 (j) 0xBB 0xBB (p)

100 420-KAB-LG Programmation orientée par objets 100 Lallocation dynamique (et application du cycle de vie) KAB-LG Programmation orientée par objets

101 101 Le tableau automatique (rappel) La taille du tableau doit être connue à la compilation: int TabEntiers [ 100 ]; Encore mieux: const int NbCases = 15; int TabValeurs [ NbCases ];

102 Exemples qui ne compilent pas Exemple 1: int NbCases = 15; int TabValeurs [ NbCases ]; Exemple 2: int NbCases; cin >> NbCases; int TabValeurs [ NbCases ]; Exemple 3: void CreerTableau(int Taille) { const int TAILLE = Taille; int Tableau[TAILLE]; } 420-KAB-LG Programmation orientée par objets 102

103 Le tableau dynamique Un tableau dynamique peut avoir une taille différente à chaque exécution Lespace mémoire est réservé à lexécution et non à la compilation comme un tableau automatique Le tableau est alloué sur le tas et non sur la pile Lutilisation dun tableau dynamique se fait en 5 étapes: 1.Déclaration dun pointeur pour contenir ladresse mémoire (le point de départ) du tableau 2.Réservation de lespace mémoire avec lopérateur new [] 3.Conserver la taille du tableau dans une variable 4.Utiliser le tableau comme sil était un tableau automatique 5.Lorsque le tableau nest plus requis, libérer l'espace en mémoire avec lopérateur delete [ ] 420-KAB-LG Programmation orientée par objets 103

104 Exemple int NbCases;// Taille du tableau int *TabEntiers;// Pointeur pour retenir ladresse // du tableau dynamique. cin >> NbCases;// Demander la taille à lusager // Allocation de la mémoire et affectation de ladresse TabEntiers = new int [NbCases]; // Utilisation du tableau for (int i = 0; i < NbCases; i++) { TabEntiers[i] = i * i; cout << TabEntiers[i] << endl; } // Destruction de la mémoire allouée. delete [] TabEntiers; 420-KAB-LG Programmation orientée par objets 104

105 Automatique vs dynamique int main() { const int Nb=10; int Tab[Nb]; // utilisation … } 420-KAB-LG Programmation orientée par objets 105 int main() { int Nb=10; int *Tab = new int[Nb]; // utilisation … delete [] Tab; }

106 420-KAB-LG Programmation orientée par objets 106 La fuite mémoire Défaut de programmation grave et difficile à trouver! Outils de vérification de code (BoundsChecker) Exemple: void Test() { int* Tab = new int[10]; // … } for(int i=0;i< ;i++) char *c = new char[10]; Le delete [] a été oublié! Ne pas essayer à la maison …

107 Encapsulation dun tableau dentiers (version allégée) CTabEntiers::CTabEntiers(int Taille) { Table_ = new int[Taille]; Taille_ = Taille; } CTabEntiers::~CTabEntiers() { delete [] Table_; } void CTabEntiers::SetElement(int Index, int Entier) { Table_[Index] = Entier; } int CTabEntiers::GetElement(int Index) const { return Table_[Index]; } 420-KAB-LG Programmation orientée par objets 107

108 Encapsulation dun tableau dentiers (suite) Que se passes-t-il lorsquon passe un objet de la classe CTabEntiers en paramètre par valeur? int main() { CTabEntiers Tab(3); Test(Tab); } Que se passe-t-il lorsquon construit un objet de la classe CTabEntiers à partir dun autre? int main() { CTabEntiers Tab1(20); CTabEntiers Tab2(Tab1); } 420-KAB-LG Programmation orientée par objets 108 void Test(CTabEntiers Param) { // … } Boum! Re- Boum!

109 Encapsulation dun tableau dentiers (suite) Il faut donc absolument définir le constructeur de copies et lopérateur daffectation de la classe CTabEntiers: public: CTabEntiers(const CTabEntiers& Original); CTabEntiers& operator=(const CTabEntiers& Original); 420-KAB-LG Programmation orientée par objets 109 La trinité Constructeur de copie Opérateur daffectation Destructeur

110 Encapsulation dun tableau dentiers Afin de compléter les fonctionnalités de la classe CTabEntiers, pouvez-vous écrire une méthode qui permettra de modifier la taille du tableau? public: void ModifierTaille(int NouvelleTaille, bool ConserverValeurs); 420-KAB-LG Programmation orientée par objets 110

111 Les tableaux dobjets Les tableaux automatiques –De types primitifs int Notes[10]; char Chaine[10]; –De type utilisateurs De structures SCompte MesComptes[10]; SPoint Flocons[10]; De classes CTasse MesTasses[10]; CMenu MesMenus[10]; –De pointeurs! Cest toujours la même syntaxe: Type Nom[TAILLE] KAB-LG Programmation orientée par objets

112 Les tableaux dobjets (suite) Les tableaux dynamiques –De types primitifs int *Tab = new int [10]; … delete [] Tab; –De type utilisateurs De structures SPoint *Flocons = new SPoint [10]; … delete [] Flocons; De classes CTasse *Tasses = new CTasse [10]; … delete [] Tasses; –De pointeurs! Cest toujours la même syntaxe: Type *Nom = new Type[TAILLE]; … delete [] Nom; KAB-LG Programmation orientée par objets

113 Les tableaux dobjets (suite) Lorsquon déclare un tableau dobjets: CMenu *MesMenus = new CMenu [10]; Ou CMenu MesMenus[10]; Il y a appel du constructeur par défaut pour chaque élément du tableau Si aucun constructeur nest défini: utilisation du constructeur automatique Si un constructeur est défini, mais pas le constructeur par défaut: erreur de compilation! (le constructeur de copie échappe à cette règle) KAB-LG Programmation orientée par objets

114 Exemple 1 - Un objet int main() { CSou Sou; Sou.Deplacer(); } 420-KAB-LG Programmation orientée par objets 114

115 Exemple 2 - Un tableau automatique dobjets int main() { const int Nb = 5; CSou Sou[Nb]; for(int i=0;i

116 Exemple 3 - Un tableau dynamique dobjets int main() { int Nb = 5; CSou* pSou = new CSou[Nb]; for(int i=0;i

117 Exemple 4 - Un pointeur dobjet int main() { CSou* pSou = new CSou(); pSou->Deplacer(); delete pSou; } 420-KAB-LG Programmation orientée par objets 117

118 Exemple 5 - Un tableau automatique de pointeurs dobjets (ex 4.8) int main() { const int Nb = 5; CSou* pSou[Nb]; for(int i=0;iDeplacer(); for(int i=0;i

119 Exemple 6 - Un tableau dynamique de pointeurs dobjets int main() { int Nb = 5; CSou** pSou; pSou = new Csou*[5]; for(int i=0;iDeplacer(); for(int i=0;i

120 420-KAB-LG Programmation orientée par objets 120 Les références & KAB-LG Programmation orientée par objets

121 Les références Tout comme le pointeur, la référence représente ladresse dun objet Contrairement au pointeur, la référence ne référera quà une seule et même chose tout au long de son existence, et devra conséquemment référer à quelque chose dès sa déclaration. On déclare une référence en préfixant son nom dun &. Une référence peut être considérée comme étant au même endroit, en mémoire, que ce à quoi elle réfère. Cest un synonyme, un alias. 420-KAB-LG Programmation orientée par objets 121

122 Les références (exemple) int main () { int i = 5; // i est un int de valeur 5 int *p = 0; // p pointe « nulle part » ! int &r = i; // r est une réference à i i++; // i devient 6, r aussi (car r // réfère à i) r++; // i devient 7, r aussi p = &i; // p pointe vers i (*p)++; // i, r et *p deviennent 8 p = &r; // p pointe là où r réfère (p // pointe vers i) } 420-KAB-LG Programmation orientée par objets 122

123 Paramètre et retour par référence dun objet CEntier ParValeur(CEntier Param) { Param.SetEntier(3); return Param; } CEntier& ParReference(CEntier& Param) { Param.SetEntier(3); return Param; } 420-KAB-LG Programmation orientée par objets 123

124 Paramètre et retour par référence dun objet (suite) CEntier Entier(1); for(int i=0;i<1000;++i) { // 2000 copies dobjets effectuées // 1000 affectations Entier = ParValeur(Entier); } for(int i=0;i<1000;++i) { // 0 copie dobjet effectuée // 1000 affectations Entier = ParReference(Entier); } 420-KAB-LG Programmation orientée par objets 124

125 Répercutions des modifications void ParValeur(CEntier Param) { Param.SetEntier(3); } void ParReference(CEntier& Param) { Param.SetEntier(3); } int main () { CEntier Entier(1); ParValeur(Entier); cout << Entier.GetEntier(); // Ceci affiche 1 ParReference (Entier); cout << Entier.GetEntier(); // Ceci affiche 3 } 420-KAB-LG Programmation orientée par objets 125

126 Les références constantes int i = 5; // i est un int de valeur 5 const int *p = 0; // p pointe « nulle part »! const int &r = i; // r est une référence à i i++; // i devient 6, r aussi // (car r réfère à i) r++; // INTERDIT!!! p = &i; // p pointe vers i (*p)++; // INTERDIT!!! p = &r; // p pointe là où r réfère // (p pointe vers i) 420-KAB-LG Programmation orientée par objets 126

127 Les références constantes et les objets Il est souvent préférable dutiliser une référence constante plutôt que de faire un passage par copie. Une référence constante sur un objet interdit dappeler une de ses méthodes qui nest pas constante car seules les méthodes constantes garantissent que lobjet ne sera pas modifié. void ReferenceConstante(const CEntier& Param) { // INTERDIT si CEntier::SetEntier(int) // nest pas const! Param.SetEntier(3); } 420-KAB-LG Programmation orientée par objets 127

128 Retour par référence constante class CTableau { CEntier Tableau_[10]; public : // Le const permet de ne pas briser lencapsulation! const CEntier& GetElement(int Index); void SetElement(int Index, int Entier); }; int main () { CTableau Tab; // INTERDIT car CEntier::SetEntier(int) // nest pas const Tab.GetElement(0).SetEntier(3); Tab.SetElement(0,3); // Ok! } 420-KAB-LG Programmation orientée par objets 128

129 420-KAB-LG Programmation orientée par objets 129 Chapitre 5 - Le polymorphisme 3 e grand principe de la POO « Qui peut prendre plusieurs formes » KAB-LG Programmation orientée par objets

130 La redéfinition de méthodes Redéfinition (override) != Surcharge (overload) 420-KAB-LG Programmation orientée par objets 130

131 La redéfinition de méthodes (suite) Méthodes avec la même signature, mais une définition différente: void CPersonne::SeDéplacer() { cout << "Marcher";} void CEtudiant::SeDéplacer() { cout << "Prendre son vélo";} void CEnseignant::SeDéplacer() { cout << "Prendre sa bmw" ; } 420-KAB-LG Programmation orientée par objets 131

132 La redéfinition de méthodes (suite) Les classes dérivées ont donc deux versions de la méthode SeDéplacer. Déterminez la version de la méthode utilisée dans les situations suivantes: CPersonne John; CEtudiant Bobby; CEnseignant Joan; John.SeDéplacer(): Bobby.SeDéplacer(); Joan.SeDéplacer(); 420-KAB-LG Programmation orientée par objets 132

133 Les pointeurs dobjets Si on déclare un pointeur vers un int, ce pointeur doit pointer vers un int. Si on fait pointer le pointeur de int vers un char, on obtient une erreur de compilation : int* p = new char; main.cpp(86) : error C2440: 'initialisation' : impossible de convertir de 'char *' en 'int *' Pour atteindre le polymorphisme, cette règle doit être assouplie pour les objets: Si on déclare un pointeur vers un objet de la classe A, ce pointeur doit pointer vers un objet de la classe A ou un objet dune classe dérivée de A. 420-KAB-LG Programmation orientée par objets 133

134 Les pointeurs dobjets (suite) Pouvez-vous déterminer les lignes qui provoquent une erreur de compilation? Cpersonne *Obj1 = new CPersonne; CPersonne *Obj2 = new CEtudiant; CPersonne *Obj3 = new CEnseignant; CEtudiant *Obj4 = new CPersonne; CEtudiant *Obj5 = new CEtudiant; CEtudiant *Obj6 = new CEnseignant; CEnseignant *Obj7 = new CPersonne; CEnseignant *Obj8 = new CEtudiant; CEnseignant *Obj9 = new CEnseignant; Il y a donc maintenant une différence entre le type de pointeur utilisé et le type réel de lobjet!! 420-KAB-LG Programmation orientée par objets 134

135 Redéfinition de méthodes et pointeurs dobjets Par défaut, la version de la méthode utilisée est déterminée par le type de pointeur utilisé. Déterminez la version de la méthode utilisée dans les exemples suivants: Cpersonne *Obj1 = new CPersonne; CPersonne *Obj2 = new CEtudiant; CPersonne *Obj3 = new CEnseignant; CEtudiant *Obj5 = new CEtudiant; CEnseignant *Obj9 = new CEnseignant; Obj1->SeDéplacer(); Obj2->SeDéplacer(); Obj3->SeDéplacer(); Obj5->SeDéplacer(); Obj9->SeDéplacer(); 420-KAB-LG Programmation orientée par objets 135

136 Les méthodes polymorphes (ou virtuelles) Idéalement, la version de la méthode utilisée devrait être déterminée par le type réel de lobjet. Pour ce faire, il faut ajouter le mot-clé virtual aux déclarations des méthodes: class CPersonne { // … virtual void SeDéplacer(); // … }; 420-KAB-LG Programmation orientée par objets 136

137 Méthodes polymorphes (suite) En supposant que la méthode SeDéplacer est virtuelle, déterminez la version de la méthode utilisée dans les exemples suivants: Cpersonne *Obj1 = new CPersonne; CPersonne *Obj2 = new CEtudiant; CPersonne *Obj3 = new CEnseignant; CEtudiant *Obj5 = new CEtudiant; CEnseignant *Obj9 = new CEnseignant; Obj1->SeDéplacer(); Obj2->SeDéplacer(); Obj3->SeDéplacer(); Obj5->SeDéplacer(); Obj9->SeDéplacer(); 420-KAB-LG Programmation orientée par objets 137

138 Appeler la méthode de la classe de base Pour effectuer une partie du traitement, la méthode dune classe dérivée peut appeler la méthode de la classe de base: void CEtudiant::SeDéplacer() { // … // Pour éviter la confusion, il faut // spécifier le nom de la classe de base CPersonne::SeDéplacer(); //… } Que se passe-t-il si on oublie le CPersonne:: ? 420-KAB-LG Programmation orientée par objets 138

139 La méthode virtuelle pure et classe abstraite La méthode virtuelle pure na pas de définition dans la classe de base (=0) class CPersonne { virtual void SeDéplacer()=0; }; Il est donc obligatoire de redéfinir les méthodes virtuelles pures dans les classes dérivées On ne peut pas créer dobjets dune classe qui possède une ou des méthodes virtuelles pures On dira donc de cette classe quelle est abstraite 420-KAB-LG Programmation orientée par objets 139

140 Exemple de polymorphisme int main() { const int N=100; CPersonne* Tab[N]; // Tableau de pointeurs for(int i=0;iSeDéplacer(); for(int i=0;i

141 420-KAB-LG Programmation orientée par objets 141 Chapitre 6 – Bibliothèque standard de C++ 1. Les entrées / sorties (istream, ostream) 2. Les fichiers (ifstream, ofstream) 3. Les chaînes de caractères (string)

142 Introduction Ensemble de classes et de fonctions standards Contient aussi la bibliothèque standard du C Contient la STL (Standard Template Library) Fait partie de la norme ISO/IEC modules:,,,,,,,,,, etc. using namespace std; 420-KAB-LG Programmation orientée par objets 142

143 420-KAB-LG Programmation orientée par objets 143 Hiérarchie des classes E/S

144 Les entrés/sorties Lutilisateur du programme entre une valeur qui nest pas autorisée: À lextérieur des bornes. Différente du type exigé par le programme. Conséquence? Sortie du programme? Mauvais fonctionnement? Prévoir les cas derreur? OUI, avec les méthodes de la classe istream 420-KAB-LG Programmation orientée par objets 144

145 Flux dentrées sorties en C KAB-LG Programmation orientée par objets 145 Un flux en C++ est une zone mémoire tampon associée à un dispositif dentrée ou de sortie qui agit comme intermédiaire entre le programme et le dispositif. Les mécanismes de tampon ont pour but doptimiser les performances des opérations dentrée / sortie

146 Flux dentrées sorties en C KAB-LG Programmation orientée par objets 146 Zones de mémoire tampon Dispositif dentrée: Clavier, fichier Programme Données Dispositif de sortie: Écran, fichier Flux de sortie Flux dentrée Données

147 La classe istream Déclarée dans la librairie iostream. Lobjet cin est une instance de cette classe. Ses méthodes sont utilisées dans les opérations de lecture. 420-KAB-LG Programmation orientée par objets 147

148 La classe istream (méthodes) istream::get() permet de lire un caractère à la fois à partir du flux dentrée standard. istream::ignore(int) permet dindiquer que lon désire ignorer, cest à dire escamoter un certain nombre de caractères en lecture. istream::fail() permet de vérifier sil y a eu échec lors de la dernière tentative de lecture dans le flux dentrée. 420-KAB-LG Programmation orientée par objets 148

149 La classe istream (méthodes) istream::clear() permet de remettre à zéro (reset) les indicateurs détat de la lecture. istream::setf(indicateur) permet de régler à vrai létat du ou des indicateurs fournis en paramètre. istream::unsetf(indicateur) permet de régler à faux létat du ou des indicateurs fournis en paramètre. 420-KAB-LG Programmation orientée par objets 149

150 La classe ostream Déclarée dans la librairie iostream. Lobjet cout est une instance de cette classe. Ses méthodes sont utilisées dans les opérations décriture. 420-KAB-LG Programmation orientée par objets 150

151 La classe ostream (méthodes) ostream::put(char) permet décrire le caractère fourni en paramètre dans le flux de sortie standard. ostream::width(int) permet de régler la largeur de la prochaine écriture à lécran. La largeur est fournie en paramètre et ne sapplique quà la prochaine écriture. ostream::fill(char) permet de fournir au flux de sortie un caractère de remplissage qui préfixera la prochaine donnée envoyée dans le flux. 420-KAB-LG Programmation orientée par objets 151

152 La classe ostream (méthodes) ostream::precision(int) permet détablir le nombre de chiffres après le point de la prochaine valeur réelle écrite à lécran. istream::setf(indicateur) permet de régler à vrai létat du ou des indicateurs fournis en paramètre. istream::unsetf(indicateur) permet de régler à faux létat du ou des indicateurs fournis en paramètre. 420-KAB-LG Programmation orientée par objets 152

153 Indicateurs Les indicateurs sont fournis en paramètre aux méthodes : istream::setf ; istream::unsetf ; ostream::setf ; ostream::unsetf sont préfixé par ios:: 420-KAB-LG Programmation orientée par objets 153

154 Indicateurs boolalpha :Affiche / lit une variable booléenne à laide de true et false ou de 1 et 0. dec : Affiche / lit un entier en base décimale. hex: Affiche / lit un entier en base hexadécimale. oct: Affiche / lit un entier en base octale. fixed:Affiche un réel à laide dun nombre fixe de chiffres après la virgule left: Affiche la valeur à la gauche du champ à afficher right : Affiche la valeur à droite du champ à afficher showpoint :Affiche le point décimal dun nombre réel. showpos : Affiche le signe plus (+) dun nombre positif. skipws: Ignore les espaces blancs lors de la lecture. 420-KAB-LG Programmation orientée par objets 154

155 Fonction obsolète getch La fonction getch() En C++, cette instruction est remplacée par: cin.ignore (cin.rdbuf () -> in_avail() + 1) 420-KAB-LG Programmation orientée par objets Vider le flux dentrée 2.Attendre quon appuie sur une touche

156 La fonction getline Fonction de la librairie istream& getline ( istream& is, string& str ); istream& getline ( istream& is, string& str, char delim ); Permet de lire une chaîne de caractères jusquà la fin de la ligne ou jusquà un délimiteur spécifique string Ligne; getline (cin, Ligne); getline (cin, Ligne,,); 420-KAB-LG Programmation orientée par objets 156

157 Convertir un int en string en C++ (*) string ToString(int Nombre) { stringstream ss; ss << Nombre; return ss.str(); } (*) itoa() cest pas du C++! 420-KAB-LG Programmation orientée par objets 157

158 Convertir un string en int en C++ (*) #include using namespace std; int ToInt(string Chaine) { int Valeur; stringstream ss; ss << Chaine; ss >> Valeur; if(ss.fail()) { // Erreur } (*) atoi() cest pas du C++! return Valeur; } 420-KAB-LG Programmation orientée par objets 158

159 Exemple 1 - Attendre void Attendre() { cout << "Appuyez sur une touche " << "pour continuer" <in_avail()+1); } 420-KAB-LG Programmation orientée par objets 159 Notez le + 1

160 Exemple 2 – Lire un entier int LireUnEntier() { int Valeur; do { cout << "Donnez un entier: " << endl; cin.clear(); cin.ignore(cin.rdbuf()->in_avail()); cin >> Valeur; } while (cin.fail()); return Valeur; } 420-KAB-LG Programmation orientée par objets 160

161 Exemple 3 - Afficher un réel double k = ; cout.setf(ios::fixed | ios::showpoint); // Attention : le fill, le precision et le // width ne s'appliquent qu'à la // prochaine écriture (jusqu'au endl) cout.fill('*'); cout.precision(3); cout.width (10); cout << k << endl; // Affiche *** KAB-LG Programmation orientée par objets 161

162 Ouverture dun fichier texte Utilisation du constructeur paramétrique: const string Nom="fichier.txt"; ofstream Fichier(Nom.c_str()); Utilisation du constructeur par défaut et de la méthode open: ofstream Fichier; cin >> Nom; Fichier.open(Nom.c_str()); Prendre note du répertoire par défaut Éviter les chemins daccès absolus Attention au \ (utiliser / ou \\) KAB-LG Programmation orientée par objets

163 Modes douverture On peut optionnellement spécifier le mode douverture du fichier au constructeur paramétrique ou à la méthode open: ofstream Fichier("monfichier.dat", ios::app); ou Fichier.open("monfichier.dat", ios::app); Les modes sont : ios::app, ios::in, ios::out, ios::trunc (défaut), ios::binary Ces modes peuvent être combinés avec lopérateur | : ios::in | ios::out | ios::app KAB-LG Programmation orientée par objets

164 Fermeture dun fichier Pour relire une autre fois le fichier, Pour permettre à dautres programmes de manipuler le fichier: Fichier.close(); 420-KAB-LG Programmation orientée par objets 164

165 Lecture et écriture dans un fichier Lecture Fichier >> Mot; Ou getline(Fichier, Ligne); Ou getline(Fichier, Ligne, Delim); ou Char = Fichier.get(); Écriture: Fichier << Infos; Méthodes utiles à lécriture: Fichier.put,.witdh,.fill,.precision 420-KAB-LG Programmation orientée par objets 165

166 Détecter la fin dun fichier getline (Fichier, Ligne); while ( ! Fichier.eof( ) ) { // Traiter la ligne lue // Essayer de lire la prochaine getline (Fichier, Ligne); } la détection de la fin de fichier nest possible quà la suite dune opération de lecture 420-KAB-LG Programmation orientée par objets 166

167 Indicateur déchec getline (Fichier, Ligne); if( Fichier.fail() ) { // On récupère lerreur // On réinitialise le flux Fichier.clear(); } 420-KAB-LG Programmation orientée par objets 167

168 Retour au début du fichier Fichier.seekg(0); Fichier.clear(); 420-KAB-LG Programmation orientée par objets 168

169 Autres méthodes La classe ifstream dérive de la classe istream: elle a donc accès à toutes les méthodes de istream: –get, ignore, fail, clear, setf et unsetf La classe ofstream dérive de la classe ostream: elle a donc accès à toutes les méthodes de ostream: –put, width, fill, precision, setf et unsetf La classe fstream dérive de istream et ostream!! 420-KAB-LG Programmation orientée par objets 169

170 Passer un flux en paramètre Puisque cout et un fichier en écriture sont tous les deux de la classe ostream: #include using namespace std; void AfficherBonjour(ostream& Flux) { Flux << "Bonjour" << endl; } int main() { ofstream Fichier("Fichier.txt"); AfficherBonjour(cout); AfficherBonjour(Fichier); } 420-KAB-LG Programmation orientée par objets 170

171 Exemple ifstream Fichier; string NomFichier; cin >> NomFichier; Fichier.open(NomFichier.c_str()); if ( ! Fichier.fail() ) { int Valeur; int Total = 0; Fichier >> Valeur; while ( ! Fichier.eof() ) { Total = Total + Valeur; Fichier >> Valeur; } cout << Total << endl; Fichier.close(); } 420-KAB-LG Programmation orientée par objets 171

172 Références classe ifstream classe ofstream classe fstream lecture-et-ecriture-dans-les-fichiers-en- c.html KAB-LG Programmation orientée par objets

173 Les chaînes de caractères En C: Une suite de caractère dans un tableau (ASCIIZ) 420-KAB-LG Programmation orientée par objets 173 c h a î n e d e c a r a c t è r e s ? chaînedecaractères?\0 string chaine = « chaîne de caractères ?» ; Une suite de caractères qui prennent un sens lorsque regroupés. En C++: Une variable de type string (objet de classe string)

174 La classe string 420-KAB-LG Programmation orientée par objets 174 Déclaration de chaînes de caractères #include using namespace std; int main() { // Déclaration et initialisation de chaînes de caractères string Message = "Entrez votre nom : "; string Nom; cout << Message; // Affichage à l'écran cin >> Nom; // Lecture au clavier // Affichage dune chaîne constante suivie de la chaîne lue au clavier cout << "Bonjour " << Nom << endl; }

175 La classe string 420-KAB-LG Programmation orientée par objets 175 Déclaration de chaînes de caractères La limite de nombre de caractères dans une chaîne = 2³² - 3 caractères (4 Go de mémoire) Indice = La position du caractère dans une chaîne, il est numéroté à partir de 0 // Déclaration et initialisation de chaînes de caractères en une seule étape string Message ( "Entrez votre nom : " );

176 La classe string 420-KAB-LG Programmation orientée par objets Affectation de chaînes de caractères string Message1( "Message à écraser" ); stringsMessage2( "Message écrasant" ); cout << "Avant affectation: " << endl; cout << Message1 << endl; cout << Message2 << endl; Message1 = Message2; //Affectation cout << "Après affectation: " << endl; cout << Message1 << endl; cout << Message2 << endl;

177 La classe string 420-KAB-LG Programmation orientée par objets 177 Affectation de chaînes de caractères Message1 = Message2; //Affectation Message1.assign (Message2); //Affectation OU

178 La classe string 420-KAB-LG Programmation orientée par objets 178 Concaténation de chaînes de caractères La concaténation est une opération qui consiste à juxtaposer bout à bout deux chaînes afin de nen former quune seule. + est lopérateur de la concaténation. s1 + s2 est différente de s2 + s1

179 La classe string 420-KAB-LG Programmation orientée par objets 179 Concaténation de chaînes de caractères // Déclaration et initialisation de chaînes de caractères string Chaine1( "Début" ); string Chaine2( "Fin" ); string Chaine3 = Chaine1 + Chaine2; //concaténation cout << "La troisième chaine est : " << endl; cout << Chaine3 << endl; cout << "Voici une quatrième chaîne : " << endl; cout << ( Chaine1 + "Milieu" + Chaine2 ) << endl;

180 La classe string 420-KAB-LG Programmation orientée par objets 180 Concaténation de chaînes de caractères + = est utilisé afin dajouter lopérande de droite dans lopérande de gauche. Message += « 123 »; Message.append (« 123 »); OU

181 La classe string 420-KAB-LG Programmation orientée par objets 181 Manipulations des caractères dans une chaînes string Chaine( "Début" ); Chaine[ 0 ] = 'R'; // modifier le 1 er caractère D pour R cout << Chaine[ 2 ]; // afficher le 3 ème caractère OU string Chaine( "Début" ); Chaine.at ( 0 ) = 'R'; // modifier le 1 er caractère D pour R cout << Chaine.at ( 2 ); // afficher le 3 ème caractère

182 La classe string 420-KAB-LG Programmation orientée par objets 182 Manipulations des caractères dans une chaînes Remarque: Il est important, lorsque vous tentez daccéder à un caractère dans la chaîne, que lindice fourni soit valide, cest-à-dire compris entre 0 et (longueur de la chaîne - 1). Si vous ne tenez pas compte de cet avertissement, vous récolterez des problèmes!!

183 La classe string 420-KAB-LG Programmation orientée par objets 183 Propriétés dune chaîne de caractères MéthodeDescription length() ou size() Retourne un entier donnant le nombre de caractères. empty()Retourne true si la chaîne est vide ; false sinon. max_size()Retourne un entier donnant le nombre de caractères maximal pouvant être emmagasinés dans la chaîne ( en VC++ ).

184 La classe string 420-KAB-LG Programmation orientée par objets 184 Propriétés dune chaîne de caractères int Longueur = Chaine.length(); // longueur de la chaine cout << "La longueur de la chaine est : " << Longueur << endl; bool Vide = Chaine.empty(); if (Vide) { cout << "La chaîne est vide !! " << endl; }

185 La classe string 420-KAB-LG Programmation orientée par objets 185 Comparaison de chaînes La comparaison de chaines seffectue selon lordre lexicographique Ordre lexicographique = ordre des caractères selon la table ASCII La présence de caractères spéciaux dans une chaine peut produire un résultat non conforme aux attentes.

186 La classe string 420-KAB-LG Programmation orientée par objets 186 Comparaison de chaînes Les opérateurs: La méthode: == != = Chaine1.compare ( Chaine2 );

187 La classe string 420-KAB-LG Programmation orientée par objets 187 if(Chaine1 == Chaine2 ) // 2 chaines égales { cout << "Les chaines sont identiques" << endl; } else if( Chaine1 != Chaine2 ) // 2 chaines différentes { if( Chaine1 < Chaine2 ) { cout << "La 1 est < que la 2" << endl; } else { cout << "La 2 est < que la 1" << endl; } Comparaison de chaînes

188 La classe string 420-KAB-LG Programmation orientée par objets 188 Comparaison de chaînes Chaine1Chaine2Message affiché "Debut" "Les chaines sont identiques" "Debut " "La 2 est < que la 1" "debut""Debut""La 2 est < que la 1" "debut""debuts""La 1 est < que la 2" "début""debut""La 2 est < que la 1"

189 La classe string 420-KAB-LG Programmation orientée par objets 189 Échange de contenu entre deux chaînes de caractères Chaine1.swap( Chaine2 ); string Temp; Temp = Chaine1; Chaine1 = Chaine2; Chaine2 = Temp; Équivalent à:

190 La classe string 420-KAB-LG Programmation orientée par objets 190 Sous-chaînes de caractères substr (int ind, int len) Méthode pour extraire une sous-chaîne de caractères contenue dans une autre. 1 er argument spécifie lindice où débute la chaîne à extraire. 2 nd argument spécifie la longueur de la sous-chaîne. Méthode pour extraire une sous-chaîne de caractères contenue dans une autre. 1 er argument spécifie lindice où débute la chaîne à extraire. 2 nd argument spécifie la longueur de la sous-chaîne.

191 La classe string 420-KAB-LG Programmation orientée par objets 191 Sous-chaînes de caractères Chaine = "Trois-Rivieres est une belle ville." cout << Chaine.substr( 6, 8 ) << endl; Rivieres

192 La classe string 420-KAB-LG Programmation orientée par objets 192 Recherche de caractères dans une chaîne MéthodeDescription find() Retourne lindice du début de la première occurrence (dans le sens de la lecture) du mot donné en argument. rfind() Retourne lindice du début de la première occurrence (dans le sens inverse de lecture) du mot donné en argument. find_first_of() Retourne lindice de la première occurrence de lun des caractères donné en argument.

193 La classe string 420-KAB-LG Programmation orientée par objets 193 Recherche de caractères dans une chaîne MéthodeDescription find_last_of() Retourne lindice de la dernière occurrence de lun des caractères donnés en argument. find_first_not_of() Retourne lindice de la première occurrence dun caractère différent de ceux donnés en argument. find_last_not_of() Retourne lindice de la dernière occurrence dun caractère différent de ceux donnés en argument.

194 La classe string 420-KAB-LG Programmation orientée par objets 194 Recherche de caractères dans une chaîne string s(" abcdefghijklmnopqrstuvwxyz allo allo" ); cout << s.find( "allo" ) << endl; cout << s.rfind( "allo" ) << endl; cout " ) << endl; cout << s.find_first_not_of( " abc" ) << endl; cout " ) << endl;

195 La classe string 420-KAB-LG Programmation orientée par objets 195 Effacer, remplacer et insérer des caractères dans une chaîne MéthodeDescription erase () Tronque la chaîne à partir dun certain indice. replace() Remplace les occurrences dun caractère par un autre caractère. insert() Insère une chaîne dans une autre à la position voulue.

196 La classe string 420-KAB-LG Programmation orientée par objets 196 Effacer, remplacer et insérer des caractères dans une chaîne string s( " " ); s.erase( 10 ); // conserve les 10 premiers caractères // Remplacer les caractères par le point. string s( "a b c d e f g h" ); int Prochain = s.find( " " ); while( Prochain <> string::npos ) { s.replace( Prochain, 1, "." ); Prochain = s.find( " ", Prochain + 1 ); } string s ( " aaaaa" ); s.insert ( 3, " !!!! " ); // Ce qui donne aaa!!!!aa

197 420-KAB-LG Programmation orientée par objets 197 Chapitre 7 – Notions avancées 1. La surcharge des opérateurs 2. Les exceptions 3. Les attributs et méthodes statiques

198 La surcharge des opérateurs Classe pour les exemples: class CBase { public: CBase(int Entier); int GetEntier() const; void SetEntier(int Entier); private: int Entier_; }; 420-KAB-LG Programmation orientée par objets 198

199 Opérateurs arithmétiques daffectation int main() { CBase Base(10); Base += 5; // Le compilateur cherche // Base.operator+=(5) ou // operator+=(Base,5) } CBase& CBase::operator+=(int Valeur) { SetEntier(GetEntier() + Valeur); return *this; } 420-KAB-LG Programmation orientée par objets 199

200 Opérateurs arithmétiques daffectation (suite) Lopérateur retourne une référence à lobjet courant pour permettre la cascade A += B += 3 (à condition que CBase& CBase::operator+=(const CBase& Base) existe) Même opérateur sous forme de fonction globale: CBase& operator+=(CBase& Base, int Valeur) { Base.SetEntier(Base.GetEntier()+Valeur); return Base; } 420-KAB-LG Programmation orientée par objets 200

201 Questions 1. Quelle est la définition de la méthode surchargeant lopérateur *= ? 2. Quelle est la définition de la fonction globale surchargeant lopérateur *= 420-KAB-LG Programmation orientée par objets 201

202 Opérateurs arithmétiques courants int main() { CBase Base1(10), Base2; Base2 = Base1 + 5; Base2 = 5 + Base1; } CBase operator+(const CBase &Base, int Valeur) { CBase Nouveau(Base.GetEntier() + Valeur); return Nouveau; } CBase operator+(int Valeur, const CBase &Base) { CBase Nouveau(Base.GetEntier() + Valeur); return Nouveau; } 420-KAB-LG Programmation orientée par objets 202

203 Questions 1. Pourquoi avons-nous utilisé des fonctions globales plutôt que des méthodes ? 2. Que retournent ces fonctions ? 3. Quelles sont les définitions des fonctions globales surchargeant lopérateur * (multiplication) 420-KAB-LG Programmation orientée par objets 203

204 Opérateurs relationnels int main() { CBase Base1(10), Base2(20); if (Base1 > Base2) //… } bool CBase::operator>(const CBase &Base) const { return GetEntier() > Base.GetEntier(); } 420-KAB-LG Programmation orientée par objets 204

205 Questions 1. Aurions-nous pu écrire la surcharge de cet opérateur sous la forme dune fonction globale? Si oui, comment ? Sinon, pourquoi ? 2. Quelle est la définition de la méthode surchargeant lopérateur == ? 3. Quelle est la définition de la fonction globale surchargeant lopérateur == ? 420-KAB-LG Programmation orientée par objets 205

206 Opérateur daffectation int main() { CBase Base1(10), Base2; Base2 = Base1; } CBase& CBase::operator=(const CBase &Base) { SetEntier(Base.GetEntier()); return *this; } 420-KAB-LG Programmation orientée par objets 206

207 Questions 1. Que retourne cette méthode ? 2. Aurions-nous pu écrire la surcharge de cet opérateur sous la forme dune fonction globale? Si oui, comment ? Sinon, pourquoi ? 3. Modifiez la définition de la méthode surchargeant lopérateur = pour prévoir le cas où le programme contient linstruction Base1 = Base1; 4. Dans quel cas la protection élaborée à la question précédente est-elle obligatoire ? 420-KAB-LG Programmation orientée par objets 207

208 Opérateur dinsertion de flux int main() { CBase Base1(10); cout << Base1; } ostream & operator<<(ostream & Flux, const CBase & Base) { Flux << Base.GetEntier(); return Flux; } 420-KAB-LG Programmation orientée par objets 208

209 Questions 1. Que retourne cette méthode ? 2. Aurions-nous pu écrire la surcharge de cet opérateur sous la forme dune méthode ? Si oui, comment ? Sinon, pourquoi ? 420-KAB-LG Programmation orientée par objets 209

210 Opérateurs dincrémentation et de décrémentation int main() { CBase Base(10); cout << ++Base; // Affiche 11 cout << Base++; // Affiche 11 } CBase & CBase::operator++() // forme préfixée ++i { SetEntier(GetEntier()+1); return *this; } CBase CBase::operator++(int) // forme suffixée i++ { CBase Temp(*this); SetEntier(GetEntier()+1); return Temp; } 420-KAB-LG Programmation orientée par objets 210

211 Questions 1. Quel est le rôle du paramètre fictif ? 2. Laquelle des deux versions est la plus rapide ? 3. Quelles sont les définitions des méthodes surchargeant lopérateur KAB-LG Programmation orientée par objets 211

212 Résumé Opérateurs sous forme de méthodes: –Accès à tous les attributs de la classe –On doit pouvoir modifier la déclaration de la classe (impossible pour ostream par exemple) –Lopérateur = ne peut être déclaré que sous la forme dune méthode –Exemples: CBase& operator+=(int ValeurAAjouter); CBase operator+(int ValeurAAjouter); bool operator>(const CBase &Base) const CBase& operator=(const CBase &Base); CBase& operator++(); CBase operator++(int); 420-KAB-LG Programmation orientée par objets 212

213 Résumé (suite) Opérateurs sous forme de fonctions globales: –Accès aux attributs publics seulement –Dans le cas où on ne peut pas modifier la déclaration de la classe –Lopérateur << ne peut être déclarée que sous la forme dune fonction non membre –Exemples: CBase& operator+=(CBase& Base, int ValeurAAjouter); CBase operator+(int ValeurAAjouter, const CBase& Base); bool operator>(const CBase& Base1, const CBase& Base2); ostream & operator<<(ostream& Flux, const CBase& Base); 420-KAB-LG Programmation orientée par objets 213

214 Opérateurs pouvant être surchargés, ! != % %= & && &= () * *= = – –– –= –> –>* / /= >= >> >>= [] ^ ^= | |= || ~ delete new Et les opérateurs de conversion: operator const char *() { Chaine_[iTaille_]=0; return Chaine; } 420-KAB-LG Programmation orientée par objets 214

215 Opérateurs ne pouvant pas être surchargés..* :: ?: sizeof 420-KAB-LG Programmation orientée par objets 215

216 Référence la-surcharge-d-operateurs.html la-surcharge-d-operateurs.html 420-KAB-LG Programmation orientée par objets 216

217 420-KAB-LG Programmation orientée par objets 217 La gestion des erreurs et les exceptions La gestion des erreurs et les exceptions KAB-LG Programmation orientée par objets

218 La gestion des erreurs par messages void CFruit::SetPoids(int Poids) { if(Poids>0) Poids_=Poids; else cout << "Poids invalide" << endl; } Il ny a pas toujours une console pour afficher les erreurs! Utiliser un fichier? Utiliser des boîtes de message? Impossible pour le programme de récupérer dune erreur! KAB-LG Programmation orientée par objets

219 La gestion des erreurs par codes de retour int CFruit::SetPoids(int Poids) { if(Poids>0) Poids_=iPoids; else return ERREUR; } Cest le cas de beaucoup de librairies Monopolise la valeur de retour Fonction appelante doit vérifier le code de retour (alourdit les programmes) Que faire pour les constructeurs? Que faire pour les destructeurs? KAB-LG Programmation orientée par objets

220 Les exceptions Façon standard de gérer les erreurs en C++ Simplifie la gestion des erreurs Trois (3) mots-clés intégrés au C++ pour gérer les erreurs: –throw: lancer une erreur –try: définir une zone de code où une erreur peut survenir –catch: attraper et traiter une erreur 420-KAB-LG Programmation orientée par objets 220

221 throw On signale ou on « lance » une exception avec throw Une exception est tout simplement un objet. Il peut être de la classe int, string, exception ou autre int CFruit::SetPoids(int Poids) { if(Poids>0) Poids_=Poids; else throw -1; // ou throw string("Poids invalide"); // ou throwCTomate(); } 420-KAB-LG Programmation orientée par objets 221 Notez bien la syntaxe! KAB-LG Programmation orientée par objets

222 throw (suite) Lorsquune exception est lancée: – Les variables locales sont détruites (appel des destructeurs pour les objets) – La fonction en cours est arrêtée – Lexception est relancée à la fonction appelante et ce, tant et aussi longtemps que lexception nest pas traitée – Si lexception remonte jusquau main et nest pas traitée par celui-ci, le programme arrête brutalement KAB-LG Programmation orientée par objets

223 try On teste des instructions sensibles avec le bloc try : try { UnFruit.SetPoids(-1); cout << UnFruit.GetPoids(); } Si une instruction lance une erreur: –le bloc try est arrêté –le programme saute au prochain bloc catch qui traite la classe dexception lancée 420-KAB-LG Programmation orientée par objets KAB-LG Programmation orientée par objets

224 catch On traite une classe dexceptions avec le bloc catch : catch(int i) { cout << " Erreur: " << i; } catch(const string& s) { cout << " Erreur: " << s; } catch(const exception& e) { cout << " Erreur: " << e.what(); } On traite toutes les classes dexceptions avec la syntaxe suivante: catch(...) { cout << "Erreur!"; } Lexécution du programme est reprise après le bloc catch 420-KAB-LG Programmation orientée par objets KAB-LG Programmation orientée par objets

225 Exemple int division(int a, int b) { if(b==0) throw string("ERREUR : Division par zéro !"); return a/b; } int main() { int a,b; cin >> a; cin >> b; try { cout << division(a, b) << endl; } catch(const string& chaine) { cout << chaine << endl; } KAB-LG Programmation orientée par objets

226 Relancer une exception On peut relancer une exception (pour en terminer le traitement par exemple) de la façon suivante: catch(const exception& e) { // On traite une première fois cerr << "ERREUR: " << e.what(); // On relance l'exception au prochain bloc catch throw; } KAB-LG Programmation orientée par objets

227 Le spécificateur dexception Indique les classes dexceptions que la méthode peut lancer Uniquement une exception de classe exception: void methode1() throw(exception); Un string ou un int void methode2() throw(string,int); Aucune exception: void methode3() throw(); N'importe quel type d'exception: void fonction4(); Le spécificateur dexception nest pas implémenté par VS 2008 et 2010! On a donc le warning suivant: warning C4290: Spécification d'exception C++ ignorée Pour désactiver ce warning: #pragma warning( disable : 4290 ) KAB-LG Programmation orientée par objets

228 Les exceptions standards La classe exception (librairie exception) est la classe de base de toutes les exceptions lancées par la bibliothèque standard (namespace std) On peut créer nos propres classes dexceptions en les dérivant de la classe exception La bibliothèque standard peut lancer des exceptions des classes bad_alloc, bad_cast, bad_exception, bad_typeid, ios_base::failure On peut utiliser les classes définies dans la librairie stdexcept: domain_error, invalid_argument, length_error, out_of_range, logic_error, range_error, overflow_error, underflow_error, runtime_error KAB-LG Programmation orientée par objets

229 Les variables statiques Variable qui existe en un seul exemplaire Valeur commune à toutes les instances (shared) Variable de classe (par opposition à variable dinstance) La variable statique est créée au démarrage du programme et non à la création dune instance 420-KAB-LG Programmation orientée par objets 229

230 Déclaration (.h) class CAvecStatiques { public: int Attrib_; static int Stat_; static const int STATCONST; }; 420-KAB-LG Programmation orientée par objets 230

231 Définition (.cpp) Il faut inclure la déclaration Enlever les static Spécifier la classe #include "AvecStatiques.h" int CAvecStatiques::Stat_ = 0; const int CAvecStatiques:: STATCONST = 5; 420-KAB-LG Programmation orientée par objets 231

232 Utilisation CAvecStatiqes X, Y; X.Stat_ = 3; cout << X.Stat_; // affiche 3 cout << Y.Stat_; // affiche 3 Y.Stat_ = 5; cout << X.Stat_; // affiche 5 cout << Y.Stat_; // affiche 5 CAvecStatiqes::Stat_ = 7; cout << CAvecStatiqes::Stat_; // Affiche 7 Il nest pas nécessaire davoir un objet pour accéder à une variable statique!! 420-KAB-LG Programmation orientée par objets 232

233 La méthode statique Méthode qui peut être appelée sans objet ce qui implique que la méthode ne peut utiliser que des variables et des méthodes statiques Déclaration class CAvecStatiques { public: static void MethodeStatique(); }; 420-KAB-LG Programmation orientée par objets 233

234 La méthode statique (suite) void CAvecStatiques::MethodeStatique() { cout << Stat_; } int main() { CAvecStatiqes X; CAvecStatiqes::Stat_ = 9; X.MethodeStatique(); // Affiche 9 // Affiche 9 CAvecStatiqes::MethodeStatique(); } 420-KAB-LG Programmation orientée par objets 234

235 Utilisation typique: Le compteur dinstances // Lapin.h class CLapin { static int NbLapins_; public: Clapin::Clapin() { NbLapins++; } Clapin::~Clapin() { NbLapins--; } static int GetNbLapins() { return NbLapins_; } }; 420-KAB-LG Programmation orientée par objets 235 // Lapin.cpp int CLapin::NbLapins_ = 0; // main.cpp int main() { CLapin A,B,C; // Affiche 3 cout << Clapin::GetNbLapins(); }

236 Utilisation typique: Le singleton class X { static X Singleton_; X(){}; // constructeur privé public: static X& GetSingleton() { return Singleton_; } }; X X::Singleton_; // Dans le cpp // Utilisation: X::GetSingleton().Methode() 420-KAB-LG Programmation orientée par objets 236


Télécharger ppt "420-KAB-LG Programmation orientée par objets 1 Chapitre 1 Introduction à la POO: –Les classes vs les objets."

Présentations similaires


Annonces Google