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

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

Chapitre 1

Introduction à la POO: –Les classes vs les objets


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 Données Données

Méthode 1

Méthode 2

Méthode 3

Méthode 4

Méthode 5

Méthode 6


Avantages de la POOPour 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 l’objet uniquement.

De façon plus générale:– Elle augmente l’intelligibilité des programmes en

rassemblant les données et les traitements qui s’appliquent à elles.

– Elle facilite la réutilisation de morceaux de programmes.

– Elle facilite la mise à jour et l’ajout de fonctionnalités.


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.


Une classe... Définition: « Idée abstraite servant à modéliser un

ensemble d’objets concrets. » Une classe se compare à un type. L’existence d’un type

ne représente rien tant qu’on n’a pas déclaré une variable. La classe n’est qu’un moule servant à créer des objets.

Un objet est aussi nommé une instance d’une classe. Une classe possède des membres:

– Attributs: variables qui représentent les données de l’objet. Les valeurs de ces données sont les états de l’objet. Chaque objet a un ensemble d’attributs (de variables) qui lui est propre.

– Méthodes: actions qui s’appliquent à l’objet ou encore services que peut rendre l’objet.

On déclare des objets d’une classe tout comme on déclare des variables d’un certain type.

La classe est une extension de la notion de structure...


Attributs ou propriétés

Définition: « Une caractéristique ou un état que possède tous les objets d’une même classe mais dont le contenu peut varier d’un objet à l’autre. »


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 d’un attribut (setter)– Obtenir la valeur d’un attribut (getter)– Effectuer un traitement plus général


Les modificateurs d’accès public:

– Le membre est visible à l’intérieur de la classe comme de l’extérieur (interface).

private:– Le membre n’est visible qu’à l’intérieur de la classe

(encapsulation). La seule différence entre une classe et une

structure est l’accès par défaut (si non spécifié):– Pour une classe: private– Pour une structure: public (rétrocompatibilité)

protected:– Le membre n’est visible qu’à l’intérieur de la classe et

ses dérivées (dans le contexte de l’héritage)


Représentation UML d’une classe

+Enseigner()+BoireUnCafé()

-Nom-Âge

Professeur

Accès:- Privé+ Publique# Protégé

Méthodes

Attributs

Nom

Conception d’une 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:

AucunLecture seule (“getter”)Lecture et écriture (“getter” et “setter”)



Trois grands principes de la POO


1. L’encapsulation Définition: « Exposer les fonctionnalités d’un

objet tout en cachant les structures de données et les détails d’implémentation. »

Indépendance:– Afin d’assurer la cohérence interne d’un 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 l’interface d’utilisation. 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.


2. L’héritage Permet la généralisation: c’est une caractéristique

importante d’un langage naturel! Simplifie les programmes en évitant la

redondance.

+Enseigner()+BoireUnCafé()

-Nom-Âge

Professeur

+Étudier()+BoireUnCafé()

-Nom-Âge

Élève

+BoireUnCafé()

-Nom-Âge

Personne

+Enseigner()

Professeur

+Étudier()

Élève


+BoireUnCafé()+Deplacer()

-Nom-Âge

Personne

+Enseigner()+Deplacer()

Professeur

+Étudier()+Deplacer()

Élève

3. Le polymorphisme Définition: « Le polymorphisme consiste à faire

abstraction de la forme. »

Prendre l’automobile

Prendre l’autobus

Méthode abstraite


Un exemple en C++class CBicyclette{public:void Freiner();void Pedaler();string ObtenirCouleur();void ModifierCouleur(string couleur);

private:string Couleur_;float Vitesse_;int Hauteur_;

};


Écriture d’une classeDé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();

}


Procédurale VS Objetsclass 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);}

Les méthodes constantesLe mot-clé const après la déclaration

d’une méthode garantit que cette méthode ne modifiera aucun des attributs de la classe.

C’est une protection pour le programmeur.C’est une excellente pratique que de

déclarer les accesseurs const (ainsi que toute autre méthode qui n’a pas besoin de modifier les attributs de l’objet).


Exemple: int GetEntier() const;

Vers la POO: Avantfloat 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;}


Ancienne façon de faire un cast

Vers la POO: Naissancestruct Fraction{ int Num; int Den;};float Quotient(Fraction Fr){ float q = 0.0f; if(Fr.Den!=0) q = static_cast<float>(Fr.Num) /

static_cast<float>(Fr.Den) ; return q;

}int main(){ Fraction Frac; Frac.Num = 3; Frac.Den = 4; cout << Quotient(Frac) << endl;}


Apparition d’un nouveau concept et regroupement des données

Vers la POO: Intégrationclass Fraction{public: int Num; int Den;

float Quotient(){ float q = 0.0f; if(Den!=0) q = static_cast<float>(Num) / static_cast<float>(Den);

return q;}

};int main(){ Fraction Frac; Frac.Num = 3; Frac.Den = 4; cout << Frac.Quotient() << endl;}


Ajout de la méthode à la classe: Regroupement des données et des méthodes qui utilisent ces données

Ce qu’il 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



Chapitre 2

Le cycle de vie

Construction Utilisation Destruction


Les services par défaut d’une classe1. La construction

– Allocation de la mémoire– Attributs non-initialisés

2. La construction d’une copie– Allocation de la mémoire– Copie membre à membre (shallow copy)

3. L’affectation entre objets d’une 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!

Exemple// Fichier EntierEncapsule.hclass CEntierEncapsule{public: int GetEntier() const; void SetEntier(int Entier);private: int Entier_;};


Exemple (suite)int main(){ CEntierEncapsule Entier1, // Construction par défaut Entier2; Entier1.SetEntier(10); AfficherObjet(Entier1); Entier2 = Entier1; // Affectation d’un objet à un

autre AfficherObjet(Entier2); system("Pause");} // Destruction des objets void AfficherObjet(CEntierEncapsule EntierEncapsule)

// Construction d’une copie{ cout << EntierEncapsule.GetEntier() << endl;} // Destruction de l’objet

// passé en paramètre


Les services par défaut (suite)

Parfois le service par défaut ne suffit pas! – Par exemple, la construction par défaut

n’initialise pas les attributs! Nous pouvons implémenter nous-mêmes

la construction d’un objet, la copie, l’affectation et la destruction d’un objet.


Les services par défaut (suite) La déclaration d’un constructeur permet

d’initialiser l’objet après l’allocation de l’objet. La déclaration d’un constructeur de copie dans

une classe remplace le constructeur de copie par défaut.

La déclaration d’un destructeur dans une classe permet de faire le ménage avant la libération de l’objet.

La surcharge de l’opérateur ‘=’ remplace le service par défaut d’affectation.



Le constructeur

Qu’affiche à l’écran le programme suivant?int main() {

CEntierEncapsule UnObjet; cout << UnObjet.GetEntier() << endl;

} Une valeur aléatoire car la construction par

défaut n’initialise pas les attributs! (comme au laboratoire!)


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

l’utilisateur de la classe d’initialiser l’objet, mais à l’objet lui-même de s’initialiser correctement!


Le constructeur (suite) Lors de la construction d’un objet, le compilateur

invoque automatiquement une méthode qui se charge de l’initialisation de l’objet. Cette méthode spéciale se nomme un constructeur.

Doit initialiser tous les attributs et exécuter toutes autres instructions requises pour initialiser l’objet.

N’a 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.


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); }


Le constructeur sans paramètre (suite)Et maintenant, qu’affiche à l’écran le programme

suivant?int main() {

CEntierEncapsule UnObjet; cout << UnObjet.GetEntier() << endl;

}

Il affiche 0 ! N’est-ce pas génial??

Appel automatique du

constructeur sans

paramètre


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); }


Les constructeurs avec paramètres (suite)

int main() {

CEntierEncapsule UnObjet(99); cout << UnObjet.GetEntier() << endl;

}

Il affiche 99 !

Appel automatiq

ue du

constr

ucteur q

ui prend un

int


La valeur par défaut d’un 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 n’est pas spécifié lors de l’appel, 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 foisAfficher("Allo"); // Affiche Allo 1 foisAfficher(); // Affiche Bonjour 1 fois

Par contre, Afficher(5) donne une erreur de compilation…


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);

};


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 fonction3. Un objet est construit à partir d’un autre

objet Son rôle est de créer une copie exacte de

l’objet passé en paramètre Sa signature est toujours la même:

– NomClasse (const NomClasse& Original);


Le constructeur de copieclass 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??

Si le constructeur de copie utilisait un passage par valeur…int main(){ A a; A b(a);}

class A{public: A(const A p);};


Appel de b.CtrCopie(a)

Appel de p.CtrCopie(a)




Les paramètres constantsUn paramètre déclaré const indique qu’il

ne pourra pas être modifié à l’inté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)


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();}


Erreur: impossible de convertir un pointeur 'this' de 'const CRect&' en ‘CRect&'


Le destructeurN’a pas de valeur de retourA le même nom que la classe préfixé du

symbole ~Effectue les instructions appropriées

lorsque l’objet est détruit– Fermeture d’un fichier– Destruction de mémoire allouée

dynamiquementPour l’instant, le service par défaut fera

l’affaire!

Le destructeur (suite)class CEntierEncapsule{public:

~CEntierEncapsule(); };CEntierEncapsule::~CEntierEncapsule(){

cout << "Rien à faire pour l’instant…" << endl;}int main() {

CEntierEncapsule UnObjet(99); cout << UnObjet.GetEntier() << endl;

}


Appel automatique du destructeur!

Les caprices des constructeurs Dès qu’au 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}



Chapitre 3 Les relations

Diagramme de classes UML


Relations entre les classesIl existe plusieurs types de relations entre

deux classes:– Aucune relation

Classes complètement indépendantes

– UtilisationSimple dépendance: paramètre,

variable locale ou valeur de retour


Relations entre les classes (suite)

– Composition

– Agrégation

– Héritage


La relation crée une dépendanceLa classe A qui a une relation avec la

classe B devient dépendante de cette dernière

Une classe dépendante d’une autre classe fait des #include « B.h »

La modification d’une classe– provoque normalement la recompilation des

classes dépendantes (erreurs?)– Peut amener un mauvais fonctionnement des

classes dépendantes420-KAB-LG Programmation orientée par objets 50

Première relation:

L’utilisation


L’utilisationUne classe peut utiliser une autre classe de

trois façons:– En paramètre d’une méthode – En variable locale dans une méthode– En valeur de retour d’une méthode


…en paramètretype 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);


… en variable localetype A::Methode(){ B b;}bool CResto::Payer(float Montant){ CFacture Facture(Montant); Facture.Imprimer(); //…}


… en valeur de retourB A::Methode(){ B b;

// …

return b;}Exemple:COeuf CPoule::Pondre(){ COeuf UnOeuf;

// …

return UnOeuf;} 420-KAB-LG Programmation orientée par objets 55

Deuxième relation:La composition



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];

};

Classes CRoue et CMoteur


CRoue

-Pression_:int

+Dégonfler()

CMoteur

-NbChevaux_:int

+GetNbChevaux():int+SetNbChevaux(entrée NbChevaux:int)

Classe CAuto améliorée


class CAuto{public:CAuto();~CAuto();CRoue& GetRoue(int Index); void Modifier(int NbChevaux);

private:CMoteur& GetMoteur(); CMoteur SuperMoteur_; CRoue Roues_[4];

};

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, c’est-à-dire que A est composée de B

A = Composée ; B= Composant420-KAB-LG Programmation orientée par objets 60

La composition

Exemples:

Un objet Auto se compose d’objets moteur et roues. Un objet Hôtel se compose d’objets ChambreHôtel Un objet Ordinateur se compose d’objets CPU,

clavier et écran Un objet mammifère se compose d’objets tête, 4

pattes

61

420-KAB-LG Programmation orientée par objets

La composition

Le composant est utilisé comme attribut du composé.

Les cycles de vie du composé et ses composants sont intimement liés.

Il s’agit d’une agréagation forte: si le composé est détruit, ses composants disparaissent aussi

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

Construction / destruction d’une composition

Si un objet B est un attribut de l’objet A, le constructeur de l’objet B sera appelé avant celui de l’objet A.

Ceci est logique: pour construire une auto, il faut d’abord construire ses composantes, comme le moteur et les roues.


Raison: Accès possible

Construction / destruction d’une composition Lors de la destruction c’est l’inverse 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


La pré-constructionCAuto::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) { }


Agrégation forte vs faible


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)

Représentation UML de la composition


L’encapsulation 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];

};


Pas d’accès direct au moteur

L’accès à une roue est en lecture seule


Exécution du programmeAuto

Troisième relation:

L’héritage(2e grand principe de la POO)


Motivation


Généralisation


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…

L’HéritageL’héritage offre la possibilité de créer une

classe à partir d’une 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.


Déclaration de CPersonneclass CPersonne{int Age_;

public:CPersonne(int Age);~CPersonne();int GetAge() const;void SeDéplacer();

};


Classe normale, rien ne change!

Déclaration de CEtudiantclass CEtudiant : public CPersonne

{int Note_;

public:CEtudiant(int Age, int Note);~CEtudiant();int GetNote() const;void Etudier();

};


Indique que la classe dérive

de CPersonne

Déclaration de Enseignantclass CEnseignant : public CPersonne

{int Salaire_;

public:CEnseignant(int Age, int Salaire);~CEnseignant();int GetSalaire() const;void Enseigner();

};


Indique que la classe dérive

de CPersonne

Exemple d’utilisationint 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();

}


Méthodes héritées de la classe parent

Méthodes héritées de la classe parent

Les modificateurs d’accèsLes membres publics d’une classe sont

utilisables par toutes les fonctions.Les membres privés d’une classe sont

utilisables uniquement par les fonctions membres de cette classe.

Les membres protégés d’une classe sont utilisables par les fonctions membres de cette classe ou d’une classe dérivée.



Construction et destructionLors de la création d’un objet de la classe

Etudiant, il y a deux constructeurs impliqués. Lorsqu’un objet Etudiant est détruit, il y a deux destructeurs qui participent à la destruction de l’objet.

1. Quel est l’ordre d’appel 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

La pré-construction Lors de la pré-construction, on peut sélectionner

le constructeur de la classe de base à utiliser pour acheminer de l’information à 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 d’un composé.



Chapitre 4 Pointeurs, allocation dynamique et

références

82


Programmation orientée par objets

Les pointeurs

0x20

0x24

5

0x20

83

Les adresses


On accède à l’adresse d’une variable (sa position en mémoire) avec le symbole &

On accède au contenu d’une 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

Les pointeurs

Un pointeur contient et permet de manipuler l’adresse d’une variable ou d’un objet.

Déclaration d’un pointeur:int *p; // Pointeur vers un intCEntier *pEntier; // Pointeur vers un CEntiershort a, *b; // a est un short, b est

// pointeur vers un short


Exemple d’utilisation d’un pointeur (1)short a, *b;*a = 5; // invalide: a n’est pas un pointeurb = &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


Exemple d’utilisation d’un 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 l’adresse de a; p pointe

// vers a *p= 4; // le contenu pointé par p ( donc

// a ) reçoit 4 b+= a; // b devient égal à 7!}


Visualiser les pointeursint a, b= 3; int *p;

p= &a;

*p= 4;


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 l’adresse 0 (zéro)

Pointeurs et POOCEntier UnEntier(4)

// Affiche 4cout << UnEntier.GetEntier();// Affiche 0072AB00 cout << &UnEntier;// Affiche 4cout << (*(&UnEntier)).GetEntier();


Pointeurs et POO (suite)// Déclaration d’un pointeur vers un // objetCEntier *pEntier = 0;// Allocation dynamique d’un objetpEntier = new CEntier(3);// Appel des méthodes de l’objet pointé// par pEntier(*pEntier).SetEntier(3);cout << (*pEntier).GetEntier() << endl;


L’opérateur ->

L’opérateur -> est une syntaxe abrégée qui permet de sélectionner un membre d’un objet pointé par un pointeur:

(*pEntier).SetEntier(3);est identique à

pEntier->SetEntier(3);


Passer un pointeur en paramètrevoid Afficher(CEntier* pEntier){ cout << pEntier->GetEntier();}int main(){ CEntier Entier(3); CEntier *pEntier = new CEntier(4); Afficher(&Entier); Afficher(pEntier);}


Passer un pointeur en paramètre (suite)Très similaire au passage par référenceIl n’y a pas de copie d’objets effectuésLes modifications apportées à l’objet dans

la méthode ou la fonction se répercuteront à l’extérieur de la méthode ou de la fonction.

Cependant, contrairement à la référence, un pointeur peut être nul ou invalide.


Retourner un pointeur

CEntier* Creer(int iValeur){ return new CEntier(iValeur);}int main(){ CEntier *pEntier = Creer(5); cout << pEntier->GetEntier();}


Erreur à ne jamais faire! (1)CEntier* Creer(int Valeur){ CEntier EntierLocal(Valeur);

return &EntierLocal;}int main(){ CEntier *pEntier = Creer(5); cout << pEntier->GetEntier();}


Détruire un objet créé dynamiquementint main(){ CEntier *pEntier = new CEntier(6); cout << pEntier->GetEntier(); // …

delete pEntier; }Il est de bon usage que celui qui créé un

objet soit responsable de le détruire.


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

Pile vs Tas


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)

0xBB0xBB (p)


L’allocation dynamique(et application du cycle de vie)



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 ];

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];

}


Le tableau dynamique Un tableau dynamique peut avoir une taille différente à

chaque exécution L’espace mémoire est réservé à l’exécution et non à la

compilation comme un tableau automatique Le tableau est alloué sur le tas et non sur la pile L’utilisation d’un tableau dynamique se fait en 5 étapes:

1. Déclaration d’un pointeur pour contenir l’adresse mémoire (le point de départ) du tableau

2. Réservation de l’espace mémoire avec l’opérateur new []

3. Conserver la taille du tableau dans une variable

4. Utiliser le tableau comme s’il était un tableau automatique

5. Lorsque le tableau n’est plus requis, libérer l'espace en mémoire avec l’opérateur delete [ ]


Exempleint NbCases; // Taille du tableauint *TabEntiers; // Pointeur pour retenir l’adresse

// du tableau dynamique.cin >> NbCases; // Demander la taille à l’usager // Allocation de la mémoire et affectation de l’adresse 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;


Automatique vs dynamique

int main(){

const int Nb=10;int Tab[Nb];

// utilisation …

}


int main(){

int Nb=10;int *Tab = new int[Nb]; // utilisation …

delete [] Tab;}


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<1000000000;i++)char *c = new char[10];

Le delete [] a été oublié!

Ne pas essayer à la maison…

Encapsulation d’un tableau d’entiers(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];}


Encapsulation d’un tableau d’entiers(suite)Que se passes-t-il lorsqu’on passe un objet de la

classe CTabEntiers en paramètre par valeur?int main(){

CTabEntiers Tab(3);Test(Tab);

}

Que se passe-t-il lorsqu’on construit un objet de la classe CTabEntiers à partir d’un autre?

int main(){

CTabEntiers Tab1(20);CTabEntiers Tab2(Tab1);


void Test(CTabEntiers Param){

// …} Bou

m!

Re-Boum!

Encapsulation d’un tableau d’entiers(suite)Il faut donc absolument définir le constructeur de

copies et l’opérateur d’affectation de la classe CTabEntiers:

public: CTabEntiers(const CTabEntiers& Original); CTabEntiers& operator=(const CTabEntiers&

Original);


La trinitéConstructeur de copie

Opérateur d’affectationDestructeur

Encapsulation d’un tableau d’entiers

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);


Les tableaux d’objets Les tableaux automatiques

– De types primitifsint Notes[10]; char Chaine[10];

– De type utilisateursDe structuresSCompte MesComptes[10]; SPoint Flocons[10];

De classesCTasse MesTasses[10]; CMenu MesMenus[10];

– De pointeurs!C’est toujours la même syntaxe:

Type Nom[TAILLE]


Les tableaux d’objets (suite)Les tableaux dynamiques

– De types primitifsint *Tab = new int [10]; … delete [] Tab;– De type utilisateurs

De structuresSPoint *Flocons = new SPoint [10]; … delete [] Flocons;

De classesCTasse *Tasses = new CTasse [10]; … delete [] Tasses;

– De pointeurs!C’est toujours la même syntaxe:

Type *Nom = new Type[TAILLE]; … delete [] Nom;


Les tableaux d’objets (suite) Lorsqu’on déclare un tableau d’objets:

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 n’est 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)


Exemple 1 - Un objetint main(){ CSou Sou; Sou.Deplacer();}


Exemple 2 - Un tableau automatique d’objetsint main(){ const int Nb = 5; CSou Sou[Nb];for(int i=0;i<NB;i++){

Sou[i].Deplacer();}

}


Exemple 3 - Un tableau dynamique d’objetsint main(){ int Nb = 5; CSou* pSou = new CSou[Nb];for(int i=0;i<Nb;i++){

pSou[i].Deplacer();}

delete[] pSou;}


Exemple 4 - Un pointeur d’objetint main(){ CSou* pSou = new CSou(); pSou->Deplacer();delete pSou;

}


Exemple 5 - Un tableau automatique de pointeurs d’objets (ex 4.8)int main(){ const int Nb = 5; CSou* pSou[Nb];for(int i=0;i<Nb;i++)

pSou[i] = new CSou;for(int i=0;i<Nb;i++)

pSou[i]->Deplacer(); for(int i=0;i<Nb;i++)

delete pSou[i];}


Exemple 6 - Un tableau dynamique de pointeurs d’objetsint main(){ int Nb = 5; CSou** pSou; pSou = new Csou*[5];

for(int i=0;i<Nb;i++)pSou[i] = new CSou;

for(int i=0;i<Nb;i++)pSou[i]->Deplacer();

for(int i=0;i<Nb;i++)delete pSou[i];

delete[] pSou;}



Les références

&120420-KAB-LG Programmation orientée par objets

Les références Tout comme le pointeur, la référence représente

l’adresse d’un 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 d’un “&”. 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. C’est un synonyme, un alias.


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)}


Paramètre et retour par référence d’un objetCEntier ParValeur(CEntier Param){ Param.SetEntier(3); return Param;}CEntier& ParReference(CEntier& Param){ Param.SetEntier(3); return Param;}


Paramètre et retour par référence d’un objet (suite)CEntier Entier(1);for(int i=0;i<1000;++i){

// 2000 copies d’objets effectuées// 1000 affectations

Entier = ParValeur(Entier); }for(int i=0;i<1000;++i){ // 0 copie d’objet effectuée // 1000 affectations

Entier = ParReference(Entier); }


Répercutions des modificationsvoid 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}


Les références constantesint i = 5; // i est un int de valeur 5const int *p = 0; // p pointe « nulle part »!const int &r = i; // r est une référence à ii++; // 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)


Les références constantes et les objets Il est souvent préférable d’utiliser une référence

constante plutôt que de faire un passage par copie. Une référence constante sur un objet interdit d’appeler

une de ses méthodes qui n’est pas constante car seules les méthodes constantes garantissent que l’objet ne sera pas modifié.

void ReferenceConstante(const CEntier& Param){

// INTERDIT si CEntier::SetEntier(int) // n’est pas const! Param.SetEntier(3);}


Retour par référence constanteclass CTableau{

CEntier Tableau_[10];public :

// Le const permet de ne pas briser l’encapsulation!

const CEntier& GetElement(int Index); void SetElement(int Index, int Entier);};int main (){

CTableau Tab; // INTERDIT car CEntier::SetEntier(int)// n’est pas constTab.GetElement(0).SetEntier(3);

Tab.SetElement(0,3); // Ok! }



Chapitre 5 - Le polymorphisme

3e grand principe de la POO

« Qui peut prendre

plusieurs formes »


La redéfinition de méthodes

Redéfinition (override) != Surcharge (overload)


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" ; }


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();


Les pointeurs d’objets 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 d’une classe dérivée de A.


Les pointeurs d’objets (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 l’objet!! 420-KAB-LG Programmation orientée par objets 134

Redéfinition de méthodes et pointeurs d’objets 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();


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 l’objet. 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

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();


Appeler la méthode de la classe de basePour effectuer une partie du traitement, la

méthode d’une 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 baseCPersonne::SeDéplacer();//…

} Que se passe-t-il si on oublie le CPersonne:: ?


La méthode virtuelle pure et classe abstraite La méthode virtuelle pure n’a 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 d’objets d’une classe qui possède une ou des méthodes virtuelles pures

On dira donc de cette classe qu’elle est abstraite


Exemple de polymorphismeint main(){

const int N=100;CPersonne* Tab[N]; // Tableau de pointeurs

for(int i=0;i<N;++i){

// Le type d’objet alloué est aléatoire!if(rand()%2==0) Tab[i] = new CEtudiant();else Tab[i] = new CEnseignant();

}// La fonction SeDéplacer change selon // le type réel de l’objet (plusieurs formes)

for(int i=0;i<N;++i)Tab[i]->SeDéplacer();

for(int i=0;i<N;++i)delete Tab[i];


Ces deux simples petits lignes illustrent

toute la beauté du polymorphisme!


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)

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 14882 52 modules:

<cmath>, <cstdio>, <cstdlib>, <ctime>, <exception>,<fstream>, <iostream>,<istream>, <ostream>, <string>, etc.

using namespace std;



Hiérarchie des classes E/S

Les entrés/sorties

L’utilisateur du programme entre une valeur qui n’est pas autorisée:

À l’extérieur des bornes. Différente du type exigé par le programme.

Conséquence?• Sortie du programme?• Mauvais fonctionnement?

Prévoir les cas d’erreur?• OUI, avec les méthodes de la classe istream


Flux d’entrées sorties en C++


Un flux en C++ est une zone mémoire tampon associée à un dispositif d’entrée ou de sortie qui agit comme intermédiaire entre le programme et le dispositif.

Les mécanismes de tampon ont pour but d’optimiser les performances des opérations d’entrée / sortie

Flux d’entrées sorties en C++


Zones de mémoire tampon

Dispositif d’entrée: Clavier, fichier

Programme

Données

Dispositif de sortie: Écran, fichier

Flux de sortie

Flux d’entrée

Données Données

Données

La classe istream

Déclarée dans la librairie iostream.

L’objet cin est une instance de cette classe.

Ses méthodes sont utilisées dans les

opérations de lecture.


La classe istream (méthodes) istream::get()

permet de lire un caractère à la fois à partir du flux d’entrée standard. istream::ignore(int)

permet d’indiquer que l’on désire ignorer, c’est à dire escamoter un certain nombre de caractères en lecture. istream::fail()

permet de vérifier s’il y a eu échec lors de la dernière tentative de lecture dans le flux d’entrée.


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.


La classe ostream

Déclarée dans la librairie iostream.

L’objet cout est une instance de cette classe.

Ses méthodes sont utilisées dans les

opérations d’écriture.


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 s’applique 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.


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.


Indicateurs

Les indicateurs sont fournis en paramètre aux

méthodes : istream::setf ; istream::unsetf ;

ostream::setf ; ostream::unsetf

sont préfixé par ios::


Indicateurs boolalpha :Affiche / lit une variable booléenne à l’aide 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 à l’aide d’un 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 d’un nombre réel. showpos : Affiche le signe plus (+) d’un nombre positif. skipws: Ignore les espaces blancs lors de la lecture.


Fonction obsolète getch

La fonction getch()

En C++, cette instruction est remplacée par:

cin.ignore (cin.rdbuf () -> in_avail() + 1)


1.Vider le flux d’entrée

2.Attendre qu’on appuie sur une touche

La fonction getlineFonction de la librairie <string>

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, ‘,’);


Convertir un int en string en C++ (*)

string ToString(int Nombre) { stringstream ss; ss << Nombre; return ss.str();}

(*) itoa() c’est pas du C++!


Convertir un string en int en C++ (*)#include <sstream>using namespace std;int ToInt(string Chaine) { int Valeur; stringstream ss; ss << Chaine; ss >> Valeur; if(ss.fail()) { // Erreur } (*) atoi() c’est pas du C++! return Valeur;}


Exemple 1 - Attendre

void Attendre(){cout << "Appuyez sur une touche "

<< "pour continuer" <<endl;cin.ignore(cin.rdbuf()->in_avail()+1);

}


Notez le

+ 1

Exemple 2 – Lire un entierint LireUnEntier(){

int Valeur;do{

cout << "Donnez un entier: " << endl;cin.clear(); cin.ignore(cin.rdbuf()->in_avail());cin >> Valeur;

}while (cin.fail());

return Valeur;}


Exemple 3 - Afficher un réel

double k = 958.943212333; 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 ***958.943


Ouverture d’un fichier texteUtilisation 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 d’accès absolusAttention au \ (utiliser / ou \\)


Modes d’ouverture On peut optionnellement spécifier le mode

d’ouverture 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 l’opérateur | :ios::in | ios::out | ios::app


Fermeture d’un fichier

Pour relire une autre fois le fichier,Pour permettre à d’autres programmes de

manipuler le fichier:

Fichier.close();


Lecture et écriture dans un fichierLecture

Fichier >> Mot;Ougetline(Fichier, Ligne);Ougetline(Fichier, Ligne, Delim);ouChar = Fichier.get();

Écriture:Fichier << Infos;

Méthodes utiles à l’écriture:Fichier.put, .witdh, .fill, .precision


Détecter la fin d’un fichiergetline (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 n’est

possible qu’à la suite d’une opération de lecture


Indicateur d’échec

getline (Fichier, Ligne);if( Fichier.fail() ) {

// On récupère l’erreur// On réinitialise le

fluxFichier.clear();

}


Retour au début du fichier

Fichier.seekg(0);Fichier.clear();


Autres méthodesLa 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!!


Passer un flux en paramètrePuisque cout et un fichier en écriture sont

tous les deux de la classe ostream:#include <iostream>#include <fstream>using namespace std;void AfficherBonjour(ostream& Flux){

Flux << "Bonjour" << endl;}int main(){

ofstream Fichier("Fichier.txt"); AfficherBonjour(cout);AfficherBonjour(Fichier);


Exempleifstream 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();


Références

http://www.cplusplus.comclasse ifstream

classe ofstream

classe fstream

http://www.siteduzero.com/tutoriel-3-36367-lecture-et-ecriture-dans-les-fichiers-en-c.html


http://www.cplusplus.com/




Les chaînes de caractères

En C: Une suite de caractère dans un tableau (ASCIIZ)


c h a î n e d e c a r a c t è r e s ?

c h a î n e d e c a r a c t è r e s ? \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)

La classe string


Déclaration de chaînes de caractères

#include <iostream>#include <string>using namespace std;

int main(){

// Déclaration et initialisation de chaînes de caractèresstring Message = "Entrez votre nom : ";string Nom;

cout << Message; // Affichage à l'écran cin >> Nom; // Lecture au clavier

// Affichage d’une chaîne constante suivie de la chaîne lue au claviercout << "Bonjour " << Nom << endl;

}

La classe string


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 : " );

La classe string


2.2 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;

La classe string


Affectation de chaînes de caractères

Message1 = Message2; //Affectation

Message1.assign (Message2); //Affectation

OU

La classe string


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

n’en former qu’une seule.

“+” est l’opérateur de la concaténation.

s1 + s2 est différente de s2 + s1

La classe string



// 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;

La classe string



“+ =” est utilisé afin d’ajouter l’opérande de

droite dans l’opérande de gauche.

Message += « 123 »;

Message.append (« 123 »);

OU

La classe string


Manipulations des caractères dans une chaînes

string Chaine( "Début" );

Chaine[ 0 ] = 'R'; // modifier le 1er 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 1er caractère ‘D’ pour ‘R’

cout << Chaine.at ( 2 ); // afficher le 3ème caractère

La classe string


Manipulations des caractères dans une chaînes

Remarque:

Il est important, lorsque vous tentez d’accéder à un caractère

dans la chaîne, que l’indice fourni soit valide, c’est-à-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!!

La classe string


Propriétés d’une chaîne de caractères

Méthode Description

length() ousize()

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 (232 - 3 en VC++ ).

La classe string


Propriétés d’une 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;}

La classe string


Comparaison de chaînes

La comparaison de chaines s’effectue selon l’ordre

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.

La classe string



Les opérateurs:

La méthode:

== != < > <= >=

Chaine1.compare ( Chaine2 );

La classe string


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;}

}


La classe string



Chaine1 Chaine2 Message affiché

"Debut" "Debut" "Les chaines sont identiques"

"Debut " "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"

La classe string


Échange de contenu entre deux chaînes de caractères

Chaine1.swap( Chaine2 );

string Temp;

Temp = Chaine1;

Chaine1 = Chaine2;

Chaine2 = Temp;

Équivalent à:

La classe string


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.

1er argument spécifie l’indice où débute la chaîne à

extraire.

2nd argument spécifie la longueur de la sous-chaîne.

La classe string


Sous-chaînes de caractères

Chaine = "Trois-Rivieres est une belle ville."

cout << Chaine.substr( 6, 8 ) << endl;

Rivieres

La classe string


Recherche de caractères dans une chaîne


find()Retourne l’indice du début de la première occurrence (dans le sens de la lecture) du mot donné en argument.

rfind()Retourne l’indice du début de la première occurrence (dans le sens inverse de lecture) du mot donné en argument.

find_first_of()Retourne l’indice de la première occurrence de l’un des caractères donné en argument.

La classe string




find_last_of()Retourne l’indice de la dernière occurrence de l’un des caractères donnés en argument.

find_first_not_of()Retourne l’indice de la première occurrence d’un caractère différent de ceux donnés en argument.

find_last_not_of()Retourne l’indice de la dernière occurrence d’un caractère différent de ceux donnés en argument.

La classe string



string s(" abcdefghijklmnopqrstuvwxyz<|>allo<|>allo" );

cout << s.find( "allo" ) << endl;

cout << s.rfind( "allo" ) << endl;

cout << s.find_first_of( "|<>" ) << endl;

cout << s.find_last_of( "|<>" ) << endl;

cout << s.find_first_not_of( " abc" ) << endl;

cout << s.find_last_not_of( "loa<|>" ) << endl;

30

37

27

36

4

26

La classe string


Effacer, remplacer et insérer des caractères dans une chaîne


erase ()Tronque la chaîne à partir d’un certain indice.

replace()Remplace les occurrences d’un caractère par un autre caractère.

insert()Insère une chaîne dans une autre à la position voulue.

La classe string


Effacer, remplacer et insérer des caractères dans une chaîne

string s( "01234567890123456789" );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


Chapitre 7 – Notions avancées

1. La surcharge des opérateurs2. Les exceptions3. Les attributs et méthodes statiques

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_;};


Opérateurs arithmétiques d’affectationint 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;}


Opérateurs arithmétiques d’affectation (suite)

L’opérateur retourne une référence à l’objet 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;

}


Questions1. Quelle est la définition de la méthode

surchargeant l’opérateur *= ?

2. Quelle est la définition de la fonction globale surchargeant l’opérateur *=


Opérateurs arithmétiques courantsint 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;}


Questions1. 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 l’opérateur * (multiplication)


Opérateurs relationnelsint main(){ CBase Base1(10), Base2(20); if (Base1 > Base2)

//…}bool CBase::operator>(const CBase &Base) const{ return GetEntier() > Base.GetEntier();}


Questions1. Aurions-nous pu écrire la surcharge de cet

opérateur sous la forme d’une fonction globale? Si oui, comment ? Sinon, pourquoi ?

2. Quelle est la définition de la méthode surchargeant l’opérateur == ?

3. Quelle est la définition de la fonction globale surchargeant l’opérateur == ?


Opérateur d’affectation

int main(){ CBase Base1(10), Base2;Base2 = Base1;

}CBase& CBase::operator=(const CBase &Base){ SetEntier(Base.GetEntier()); return *this; }


Questions1. Que retourne cette méthode ?2. Aurions-nous pu écrire la surcharge de cet

opérateur sous la forme d’une fonction globale? Si oui, comment ? Sinon, pourquoi ?

3. Modifiez la définition de la méthode surchargeant l’opérateur = pour prévoir le cas où le programme contient l’instruction Base1 = Base1;

4. Dans quel cas la protection élaborée à la question précédente est-elle obligatoire ?


Opérateur d’insertion de fluxint main(){ CBase Base1(10); cout << Base1;

}ostream & operator<<(ostream & Flux, const CBase & Base)

{ Flux << Base.GetEntier(); return Flux;

}


Questions

1. Que retourne cette méthode ?

2. Aurions-nous pu écrire la surcharge de cet opérateur sous la forme d’une méthode ? Si oui, comment ? Sinon, pourquoi ?


Opérateurs d’incrémentation et de décrémentationint 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;}


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 l’opérateur --


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)– L’opérateur = ne peut être déclaré que sous la forme

d’une méthode

– Exemples: CBase& operator+=(int ValeurAAjouter);CBase operator+(int ValeurAAjouter);bool operator>(const CBase &Base) constCBase& operator=(const CBase &Base); CBase& operator++(); CBase operator++(int);


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– L’opérateur << ne peut être déclarée que sous la

forme d’une 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);


Opérateurs pouvant être surchargés, ! != % %= & && &= () * *= + ++ += – –– –= –> –>* / /= < << <<= <= = == > >= >> >>= [] ^ ^= | |= || ~ delete new

Et les opérateurs de conversion:operator const char *() { Chaine_[iTaille_]=0; return Chaine; }


Opérateurs ne pouvant pas être surchargés..*::?:sizeof


Référence

http://www.siteduzero.com/tutoriel-3-11199-la-surcharge-d-operateurs.html





La gestion des erreurs et les exceptions


La gestion des erreurs par messagesvoid CFruit::SetPoids(int Poids){ if(Poids>0)

Poids_=Poids;else

cout << "Poids invalide" << endl;} Il n’y 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 d’une erreur!


La gestion des erreurs par codes de retourint CFruit::SetPoids(int Poids){ if(Poids>0)

Poids_=iPoids;else

return ERREUR; } C’est 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?


Les exceptionsFaçon standard de gérer les erreurs en C++Simplifie la gestion des erreursTrois (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


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 autreint CFruit::SetPoids(int Poids){

if(Poids>0)Poids_=Poids;

elsethrow -1;// ou throw string("Poids invalide"); // ou throw CTomate();

}


Notez bien la

syntaxe

!


throw (suite)Lorsqu’une exception est lancée:

– Les variables locales sont détruites (appel des destructeurs pour les objets)

– La fonction en cours est arrêtée– L’exception est relancée à la fonction

appelante et ce, tant et aussi longtemps que l’exception n’est pas traitée

– Si l’exception remonte jusqu’au main et n’est pas traitée par celui-ci, le programme arrête brutalement.


tryOn 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 d’exception lancée

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

catch On traite une classe d’exceptions 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 d’exceptions avec la syntaxe suivante:catch(...){

cout << "Erreur!";}

L’exécution du programme est reprise après le bloc catch

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

Exempleint 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; }}


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 foiscerr << "ERREUR: " << e.what();// On relance l'exception au prochain bloc catch

throw;

}


Le spécificateur d’exception Indique les classes d’exceptions 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 d’exception n’est 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 )


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 d’exceptions 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


Les variables statiques

Variable qui existe en un seul exemplaireValeur commune à toutes les instances

(shared)Variable de classe (par opposition à

variable d’instance)La variable statique est créée au démarrage

du programme et non à la création d’une instance


Déclaration (.h)

class CAvecStatiques{public: int Attrib_; static int Stat_; static const int STATCONST;};


Définition (.cpp)

Il faut inclure la déclarationEnlever les staticSpécifier la classe

#include "AvecStatiques.h"int CAvecStatiques::Stat_ = 0;const int CAvecStatiques:: STATCONST = 5;


UtilisationCAvecStatiqes X, Y;X.Stat_ = 3; cout << X.Stat_; // affiche 3cout << Y.Stat_; // affiche 3Y.Stat_ = 5; cout << X.Stat_; // affiche 5cout << Y.Stat_; // affiche 5CAvecStatiqes::Stat_ = 7;cout << CAvecStatiqes::Stat_; // Affiche 7

Il n’est pas nécessaire d’avoir un objet pour accéder à une variable statique!!


La méthode statiqueMé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éclarationclass CAvecStatiques{public: static void MethodeStatique();};


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(); }


Utilisation typique: Le compteur d’instances

// Lapin.hclass CLapin{ static int NbLapins_;public: Clapin::Clapin() { NbLapins++; } Clapin::~Clapin() { NbLapins--; } static int GetNbLapins() { return NbLapins_; }};


// Lapin.cppint CLapin::NbLapins_ = 0;

// main.cppint main() { CLapin A,B,C; // Affiche 3 cout << Clapin::GetNbLapins(); }

Utilisation typique: Le singletonclass X { static X Singleton_; X(){}; // constructeur privépublic: static X& GetSingleton() { return Singleton_; }};X X::Singleton_; // Dans le cpp// Utilisation:X::GetSingleton().Methode()


Documents

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