420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Chapitre 1Introduction à la POO:
–Les classes vs les objets
420-KAB-LG Programmation orientée par objets 1
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Programmation procédurale ou orientée par objets? La programmation procédurale:
La programmation orientée par objets:
420-KAB-LG Programmation orientée par objets 2
Tas de donnéesMé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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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. 420-KAB-LG Programmation orientée par objets 3
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 robot, 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.
420-KAB-LG Programmation orientée par objets 4
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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...
420-KAB-LG Programmation orientée par objets 5
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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. »
420-KAB-LG Programmation orientée par objets 6
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 (mutateur)– Obtenir la valeur d’un attribut (accesseur)– Effectuer un traitement plus général
420-KAB-LG Programmation orientée par objets 7
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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)420-KAB-LG Programmation orientée par objets 8
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Représentation UML d’une classe
420-KAB-LG Programmation orientée par objets 9
Accès:- Privé+ Publique# Protégé
Méthodes
Attributs
Nom
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Conception d’une classe... Une classe a des méthodes et des attributs
(on peut faire la distinction entre un attribut fixe (caractéristique) ouvariable (état))
La classe se protège et assure sa cohérenceinterne!
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 (accesseur) Lecture et écriture (mutateur et accesseur)
420-KAB-LG Programmation orientée par objets 10
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Trois grands principes de la POO
420-KAB-LG Programmation orientée par objets 11
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 12
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 13
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
3. Le polymorphisme Définition: « Le polymorphisme consiste à faire
abstraction de la forme. »
420-KAB-LG Programmation orientée par objets 14
Prendre l’automobile
Prendre l’autobus
Méthode abstraite
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Un exemple en C++class CBicyclette{public:void Freiner();void Pedaler();string ObtenirCouleur() const;void ModifierCouleur(string couleur);
private:string Couleur_;float Vitesse_;int Hauteur_;
};
420-KAB-LG Programmation orientée par objets 15
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
É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;}int CEntierEncapsule::GetEntier() const{
return Entier_;}
420-KAB-LG Programmation orientée par objets 16
Utilisation:int main() {
CEntierEncapsule UnObjet;UnObjet.SetEntier( 10 );cout << UnObjet.GetEntier();
}
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Procédurale VS Objetsclass CPersonne{public:
int Age;bool EstAdulte() {
return Age >=18;}
};
int main(){
CPersonne Joan;Joan.Age = 19;cout << Joan.EstAdulte();
}420-KAB-LG Programmation orientée par objets 17
bool EstAdulte(int Param){
return Param>= 18;}
int main(){
int Age;Age= 19;cout << EstAdulte(Age);
}
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les méthodes constantes Le 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).
420-KAB-LG Programmation orientée par objets 18
Exemple: int GetEntier() const;
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
}
420-KAB-LG Programmation orientée par objets 19
Ancienne façon de faire un cast
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
} 420-KAB-LG Programmation orientée par objets 20
Apparition d’un nouveau concept et regroupement des données
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
} 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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets 22
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Chapitre 2Le cycle de vie
420-KAB-LG Programmation orientée par objets 23
Construction Utilisation Destruction
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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!420-KAB-LG Programmation orientée par objets 24
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple// Fichier EntierEncapsule.hclass CEntierEncapsule{public:
int GetEntier() const;void SetEntier(int Entier);
private:int Entier_;
};
420-KAB-LG Programmation orientée par objets 25
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple (suite)int main(){
CEntierEncapsule Entier1, // Construction par défautEntier2;
Entier1.SetEntier(10);AfficherObjet(Entier1);Entier2 = Entier1; // Affectation d’un objet à un autreAfficherObjet(Entier2);
} // Destruction des objets
void AfficherObjet(CEntierEncapsule Param)// Construction d’une copie
{cout << Param.GetEntier() << endl;
} // Destruction de l’objet// passé en paramètre
420-KAB-LG Programmation orientée par objets 26
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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ême la
construction d’un objet, la copie, l’affectation et la destruction d’un objet.
420-KAB-LG Programmation orientée par objets 27
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 28
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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!)
420-KAB-LG Programmation orientée par objets 29
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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!
420-KAB-LG Programmation orientée par objets 30
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
Il 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.
420-KAB-LG Programmation orientée par objets 31
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Le constructeur sans paramètres
Il est unique!
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);}
420-KAB-LG Programmation orientée par objets 32
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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??
420-KAB-LG Programmation orientée par objets 33
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les constructeurs avec paramètre(s) 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);}
420-KAB-LG Programmation orientée par objets 34
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les constructeurs avec paramètres (suite)
int main() {
CEntierEncapsule UnObjet(99);
cout << UnObjet.GetEntier() << endl;
}
Il affiche 99 !420-KAB-LG Programmation orientée par objets 35
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 fois
Afficher("Allo"); // Affiche Allo 1 fois
Afficher(); // Affiche Bonjour 1 fois
Par contre, Afficher(5) donne une erreur de compilation…
420-KAB-LG Programmation orientée par objets 36
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
class CPersonne{public:
CPersonne(string Nom="Roger", int Age=20);// remplace avantageusement:// CPersonne();// CPersonne(string Nom);// CPersonne(string Nom, int Age);
};
420-KAB-LG Programmation orientée par objets 37
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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);
420-KAB-LG Programmation orientée par objets 38
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Le constructeur de copieclass CEntierEncapsule{public:
CEntierEncapsule(constCEntierEncapsule& Original);
};
CEntierEncapsule::CEntierEncapsule(constCEntierEncapsule& Original)
{Entier_ = Original.GetEntier();
// ou encore mieux: SetEntier(Original.GetEntier() );}
Pourquoi un passage par référence??420-KAB-LG Programmation orientée par objets 39
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Si le constructeur de copie utilisait un passage par valeur…void Test(A p){}class A{public:
A(A p);};int main(){
A a;Test(a);
}
420-KAB-LG Programmation orientée par objets 40
Appel de p.CtrCopie(a)
Appel de p.CtrCopie(a)
Appel de p.CtrCopie(a)
Appel de p.CtrCopie(a)
Appel de p.CtrCopie(a)
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les paramètres constants Un 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(constCEntierEncapsule& Original)
420-KAB-LG Programmation orientée par objets 41
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 'constCRect&' en ‘CRect&'
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Le destructeur N’a pas de valeur de retour A 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
dynamiquement Pour l’instant, le service par défaut fera
l’affaire!420-KAB-LG Programmation orientée par objets 43
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
}
420-KAB-LG Programmation orientée par objets 44
Appel automatique du destructeur!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
}
420-KAB-LG Programmation orientée par objets 45
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Chapitre 3Les relations
420-KAB-LG Programmation orientée par objets 46
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Diagramme de classes UML
420-KAB-LG Programmation orientée par objets 47
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Relations entre les classes (suite)
– Composition
– Agrégation
– Héritage
420-KAB-LG Programmation orientée par objets 49
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Première relation:
L’utilisation
420-KAB-LG Programmation orientée par objets 51
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
L’utilisation Une 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
420-KAB-LG Programmation orientée par objets 52
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
…en paramètretype A::Methode(B b)type A::Methode(B& b)type A::Methode(const B& b)Exemples:bool CBanque::Bloquer(CCompte 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
Copie!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
… en variable localetype A::Methode(){
B b;}bool CResto::Payer(float Montant){
CFacture Facture(Montant);Facture.Imprimer();//…
}420-KAB-LG Programmation orientée par objets 54
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
… 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
Copie!
Copie!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Deuxième relation:La composition
420-KAB-LG Programmation orientée par objets 56
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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];
}; 420-KAB-LG Programmation orientée par objets 57
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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)
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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];
};
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets 61
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La composition
Le composant est utilisé comme attributdu composé.
Les cycles de vie du composé et ses composants sont intimement liés.
Il s’agit d’une agrégation forte: si le composé est détruit, ses composants disparaissent aussi
420-KAB-LG Programmation orientée par objets 62
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 63
Raison: Accès possible
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets 6464
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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) { }
420-KAB-LG Programmation orientée par objets 65
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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îtpas si le composé est détruit. Exemples: (Aéroport et avions), (Train et
wagons), (groupe et étudiants), (Ferme et animaux)
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Représentation UML de la composition
420-KAB-LG Programmation orientée par objets 67
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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];
};
420-KAB-LG Programmation orientée par objets 68
Pas d’accès direct au moteur
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exécution du programmeAuto
420-KAB-LG Programmation orientée par objets 69
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Troisième relation:L’héritage(2e grand principe de la POO)
420-KAB-LG Programmation orientée par objets 70
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Motivation
420-KAB-LG Programmation orientée par objets 71
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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…
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
L’Héritage L’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.
420-KAB-LG Programmation orientée par objets 73
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Déclaration de CPersonneclass 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!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Déclaration de CEtudiantclass 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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Déclaration de Enseignantclass 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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple d’utilisationint main(){CEtudiant Paul(19, 85);Paul.Etudier();cout << Paul.GetNote();Paul.SeDé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
Méthodes héritées de la classe parent
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les modificateurs d’accès Les 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.
420-KAB-LG Programmation orientée par objets 78
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 79
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Construction et destructionLors de la création d’un objet de la classe
CEtudiant, il y a deux constructeurs impliqués. Lorsqu’un objet CEtudiant 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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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é.
420-KAB-LG Programmation orientée par objets 81
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 8282
Chapitre 4 Pointeurs, allocation dynamique et
références
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 8383
Programmation orientée par objets
Les pointeurs(indirection, raccourci, référence)
0x20
0x24
5
0x20
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 a = 3; cout << a; // Affiche 3cout << &a; // Affiche 0068FDF4cout << *(&a); // Affiche 3, *(&a) = a
420-KAB-LG Programmation orientée par objets 84
La variable a peut être de type primitif (int,
char, …) ou un objet
* &
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les pointeurs Un pointeur contient 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
420-KAB-LG Programmation orientée par objets 85
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple d’utilisation d’un pointeur (1)short a, *b;
*a = 5; // invalide: a n’est 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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple d’utilisation d’un pointeur (2)int a, // valeur de a: indéterminée
b= 3; // valeur de b: 3int *p; // p est un pointeur vers un intp= &a; // p reçoit l’adresse de a
// donc p pointe vers a*p= 4; // le contenu pointé par p
// ( donc a ) reçoit 4b+= a; // b devient égal à 7!
420-KAB-LG Programmation orientée par objets 87
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Visualiser les pointeursint a, b= 3; int *p;
p= &a;
*p= 4;
420-KAB-LG Programmation orientée par objets 88
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Initialiser un pointeurint *p = nullptr; // (…)if (p != nullptr){
// ... 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 NULLEn C++ on utilisait l’adresse 0 (zéro)
En C++11, on utilise nullptr
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Déclaration vs instruction
Déclaration Instruction
* Déclare un pointeurint *p;void fonction(int *p);
Ce qui est pointé parcout << *p;a = *p;Fonction(*p);
& Déclare une référenceint &r = i;void fonction(int& r);
L’adresse decout << &i;Fonction(&i);
420-KAB-LG Programmation orientée par objets 90
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Pointeurs et POOCEntier UnEntier(4);
// Affiche 4cout << UnEntier.GetEntier();// Affiche 0072AB00 cout << &UnEntier;// Affiche 4cout << (*(&UnEntier)).GetEntier();
420-KAB-LG Programmation orientée par objets 91
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Pointeurs et POO (suite)// Déclaration d’un pointeur vers un // objetCEntier *pEntier = nullptr;// 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;
420-KAB-LG Programmation orientée par objets 92
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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);
420-KAB-LG Programmation orientée par objets 93
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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);
}420-KAB-LG Programmation orientée par objets 94
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Passer un pointeur en paramètre (suite) Très similaire au passage par référence Il n’y a pas de copie d’objets effectués Les 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.
420-KAB-LG Programmation orientée par objets 95
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Retourner un pointeurCEntier* Creer(int Valeur){
return new CEntier(Valeur);}int main(){
CEntier *pEntier = Creer(5);cout << pEntier->GetEntier();
}420-KAB-LG Programmation orientée par objets 96
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Erreur à ne jamais faire! (1)CEntier* Creer(int Valeur){
CEntier EntierLocal(Valeur);return &EntierLocal;
}int main(){
CEntier *pEntier = Creer(5);cout << pEntier->GetEntier();
}
420-KAB-LG Programmation orientée par objets 97
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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ée un objet soit responsable de le détruire.
420-KAB-LG Programmation orientée par objets 98
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Erreur à ne jamais faire! (2)
CEntier Entier(3);CEntier *pEntier = nullptr;CEntier *pEntier2 = nullptr;pEntier = &Entier;pEntier2 = pEntier;delete pEntier;
delete pEntier2; 420-KAB-LG Programmation orientée par objets 99
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Pile vs Tasint main(){int i = 2;CEtudiant *p = nullptr;p = new CEtudiant();test(i);delete p;
}void test(int j){cout << j;
}
420-KAB-LG Programmation orientée par objets 100
Pile
Tas
2 (i)2 (i)
null (p)null (p)
CEtudiantCEtudiant
2 (j)2 (j)
0xBB0xBB (p)0xBB (p)
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 101420-KAB-LG Programmation orientée par objets 101
L’allocation dynamique(et application du cycle de vie)
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Le tableau automatique (rappel) La taille du tableau doit être connue à la
compilation:int TabEntiers [ 100 ];
Encore mieux:const int NbCases = 100;int TabEntiers [ NbCases ];
420-KAB-LG Programmation orientée par objets 102
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 103
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 variable4. Utiliser le tableau comme s’il était un tableau automatique5. Lorsque le tableau n’est plus requis, libérer l'espace en
mémoire avec l’opérateur delete [ ]
420-KAB-LG Programmation orientée par objets 104
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
420-KAB-LG Programmation orientée par objets 105
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Automatique vs dynamiqueint main(){
const int Nb=10;
int Tab[Nb];
// utilisation …
}
420-KAB-LG Programmation orientée par objets 106
int main(){
int Nb=10;
int* Tab = new int[Nb];
// utilisation …
delete [] Tab;}
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les tableaux - Résumé Les tableaux automatiques
– De types primitifs: int Notes[10];
– De type utilisateurs De structures: Compte MesComptes[10];
De classes: CTasse MesTasses[10];
– De pointeurs: CTasse* MesTassesPtr[10];
C’est toujours la même syntaxe:Type Nom[Taille];
420-KAB-LG Programmation orientée par objets 107
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les tableaux - Résumé Les tableaux dynamiques
– De types primitifsint* Tab = new int [10]; … delete [] Tab;– De type utilisateurs
De structuresPoint* Flocs = new Point [10]; … delete [] Flocs; De classesCTasse* Tasses = new CTasse[10]; … delete [] Tasses;
– De pointeurs!CTasse** Tasses = new CTasse*[10]; … delete[] Tasses;
C’est toujours la même syntaxe:Type* Nom = new Type[Taille]; … delete [] Nom;
420-KAB-LG Programmation orientée par objets 108
!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les tableaux d’objets 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)
420-KAB-LG Programmation orientée par objets 109
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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];
420-KAB-LG Programmation orientée par objets 110
Le delete [] a été oublié!
Ne pas essayer à la maison…
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Retour sur les tableaux d'objetsExemple 1 - Un objet
int main(){
CSou Sou; Sou.Deplacer();
}
420-KAB-LG Programmation orientée par objets 111
Appel d'un constructeur
Appel du destructeur
Objet sur la Pile
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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();}
}420-KAB-LG Programmation orientée par objets 112
Appels des constructeurs par défaut
Appels des destructeurs
Tableau sur la Pile
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
} 420-KAB-LG Programmation orientée par objets 113
Appels des constructeurs par défaut
Appels des destructeurs
Tableau dans le
tas
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple 4 - Un pointeur d’objetint main(){
CSou* pSou = new CSou; pSou->Deplacer();delete pSou;
}Un objet ou un tableau dans le tas n'est pas
détruit automatiquement lorsque la fonctionse termine, il faut s'assurer de toujours garderun pointeur...
420-KAB-LG Programmation orientée par objets 114
Appel d'un constructeur
Objet dans le
tas
Appel du destructeur
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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];}
420-KAB-LG Programmation orientée par objets 115
Appel d'un constructeur
Objets dans le
tas
Appel du destructeur
Tableau de pointeurs sur la pile
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple 6 - Un tableau dynamiquede pointeurs d’objets (optionnel)int main(){
int Nb = 5;CSou** pSou;pSou = new CSou*[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];delete[] pSou;
}420-KAB-LG Programmation orientée par objets 116
Appel d'un constructeur
Appel du destructeur
Tableau de pointeurs dans le tas
Objets dans le tas
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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];}
420-KAB-LG Programmation orientée par objets 117
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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);
} 420-KAB-LG Programmation orientée par objets 118
void Test(CTabEntiers Param){
// …} Boum!
Re-Boum!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Encapsulation d’un tableau d’entiers(suite)Il faut donc absolument définir le constructeur de
copie et l’opérateur d’affectation de la classe CTabEntiers:
public:CTabEntiers(const CTabEntiers& Original);CTabEntiers& operator=(const CTabEntiers& Original);
420-KAB-LG Programmation orientée par objets 119
La trinitéConstructeur de copie
Opérateur d’affectationDestructeur
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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);
420-KAB-LG Programmation orientée par objets 120
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
121420-KAB-LG Programmation orientée par objets 121
Les références
&
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 122
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les références (exemple)int main (){
int i = 5; // i est un int de valeur 5int *p = 0; // p pointe « nulle part » ! int &r = i; // r est une réference à ii++; // i devient 6, r aussi (car r
// réfère à i)r++; // i devient 7, r aussip = &i; // p pointe vers i(*p)++; // i, r et *p deviennent 8p = &r; // p pointe là où r réfère (p
// pointe vers i)}
420-KAB-LG Programmation orientée par objets 123
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
}
420-KAB-LG Programmation orientée par objets 124
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 affectationsEntier = ParValeur(Entier);
}for(int i=0;i<1000;++i){
// 0 copie d’objet effectuée// 1000 affectations (qui pourraient être évitées)Entier = ParReference(Entier);
}
420-KAB-LG Programmation orientée par objets 125
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 1ParReference (Entier);cout << Entier.GetEntier(); // Ceci affiche 3
}
420-KAB-LG Programmation orientée par objets 126
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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)
420-KAB-LG Programmation orientée par objets 127
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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);
}
420-KAB-LG Programmation orientée par objets 128
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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!
} 420-KAB-LG Programmation orientée par objets 129
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
130420-KAB-LG Programmation orientée par objets 130
Chapitre 5 - Le polymorphisme
3e grand principe de la POO
« Qui peut prendre
plusieurs formes »
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La redéfinition de méthodes
Redéfinition (override) != Surcharge (overload)420-KAB-LG Programmation orientée par objets 131
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 132
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 133
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 intvers 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.
420-KAB-LG Programmation orientée par objets 134
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 135
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Redéfinition de méthodes et pointeurs d’objets 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();
Par défaut, la version de la méthode utilisée est déterminée par le type de pointeur utilisé.
420-KAB-LG Programmation orientée par objets 136
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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é virtualaux déclarations des méthodes:
class CPersonne
{
// …
virtual void SeDéplacer();
// …
};420-KAB-LG Programmation orientée par objets 137
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 138
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple de polymorphismeint main(){
const int N=100;CPersonne* Tab[N]; // Tableau de pointeursfor(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 méthode SeDeplacer 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];
} 420-KAB-LG Programmation orientée par objets 139
Ces deux simples petits lignes illustrent
toute la beauté du polymorphisme!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Appeler la méthode de la classe de base Pour 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:: ?420-KAB-LG Programmation orientée par objets 140
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 abstraite420-KAB-LG Programmation orientée par objets 141
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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)
420-KAB-LG Programmation orientée par objets 142
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 du C++11 Elle contient différents modules:
– Entrées/sorties– Chaînes de caractères– Structures de données– Algorithmes– Temps, tâches, etc.
using namespace std;420-KAB-LG Programmation orientée par objets 143
Ensemble de classes,
constantes, fonctions, etc.
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Hiérarchie des classes E/S
420-KAB-LG Programmation orientée par objets 144
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les entrés/sortiesL’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
420-KAB-LG Programmation orientée par objets 145
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets 146
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Flux d’entrées sorties en C++
420-KAB-LG Programmation orientée par objets 147
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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 148
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 149
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 150
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 151
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 152
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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. ostream::setf(indicateur) permet de régler à vrai l’état du ou des indicateurs fournis en paramètre. ostream::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 153
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 154
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 155
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 tampon d’entrée2.Attendre qu’on appuie sur une touche
420-KAB-LG Programmation orientée par objets 156
Équivalent de system("pause");
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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écifiquestring Ligne;
getline(cin, Ligne);
getline(cin, Ligne, ‘,’);
420-KAB-LG Programmation orientée par objets 157
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Convertir un int en string en C++03 (*)string ToString(int Nombre) {
stringstream ss;ss << Nombre;return ss.str();
}
420-KAB-LG Programmation orientée par objets 158
(*) itoa() c’est pas du C++, c’est du C et ce n’est pas supporté par tous les compilateurs!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Convertir un string en int en C++03 (*)#include <sstream>using namespace std;int ToInt(string Chaine) {
int Valeur;stringstream ss;ss << Chaine;ss >> Valeur;if(ss.fail()) { // Erreur }return Valeur;
}(*) atoi() c’est pas du C++!
420-KAB-LG Programmation orientée par objets 159
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Conversions de types en C++11
Le C++11 a introduit des fonctions dans std::string pour permettre des conversions efficacement et simplement
stoi(), stod(), stof() acceptent un string et retournent sa conversion en integer, double et float, respectivement
to_string() accepte un nombre, peu importe son type, et retourne un string contenant ce nombre.
420-KAB-LG Programmation orientée par objets 160
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Conversions de types en C++11
#include <string>
float Pi = 3.14159;int Nombre = 2;int N2;string NS;string Age = "32";
NS = to_string(Pi);N2 = stoi(Age);
420-KAB-LG Programmation orientée par objets 161
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple 1 - Attendrevoid Attendre(){cout << "Appuyez sur une touche "
<< "pour continuer" << endl;cin.ignore(cin.rdbuf()->in_avail()+1);
}
420-KAB-LG Programmation orientée par objets 162
Équivalent de system("pause");
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple 2 – Lire un entierint LireUnEntier(){
int Valeur;do{
cout << "Donnez un entier: " << endl;// Efface les erreurs précédentescin.clear(); // Vider le buffer d’entréecin.ignore(cin.rdbuf()->in_avail());cin >> Valeur;
}while (cin.fail());return Valeur;
} 420-KAB-LG Programmation orientée par objets 163
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exemple 3 - Afficher un réeldouble 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
420-KAB-LG Programmation orientée par objets 164
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Ouverture d’un fichier texte Utilisation du constructeur paramétrique:
const string Nom="fichier.txt";ifstream Fichier(Nom);
Utilisation du constructeur par défaut et de la méthode open:ifstream Fichier;cin >> Nom;Fichier.open(Nom);
Prendre note du répertoire par défaut Éviter les chemins d’accès absolusAttention au \ (utiliser / ou \\)
420-KAB-LG Programmation orientée par objets 165
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets 166
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Fermeture d’un fichier
Pour relire une autre fois le fichier, Pour permettre à d’autres programmes de
manipuler le fichier:
Fichier.close();
420-KAB-LG Programmation orientée par objets 167
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets 168
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Détecter la fin d’un fichierwhile ( ! 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
420-KAB-LG Programmation orientée par objets 169
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Indicateur d’échec
getline (Fichier, Ligne);if( Fichier.fail() ) {
// On récupère l’erreur// On réinitialise le fluxFichier.clear();
}
420-KAB-LG Programmation orientée par objets 170
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Retour au début du fichier
Fichier.seekg(0);Fichier.clear();
420-KAB-LG Programmation orientée par objets 171
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 172
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Passer un flux en paramètre Puisque 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);
}420-KAB-LG Programmation orientée par objets 173
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Exempleifstream Fichier;string NomFichier;cin >> NomFichier;Fichier.open(NomFichier);if ( ! Fichier.fail() ){
int Valeur;int Total = 0;while ( ! Fichier.eof() ){
Fichier >> Valeur;Total = Total + Valeur;
}cout << Total << endl;Fichier.close();
}420-KAB-LG Programmation orientée par objets 174
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Références
http://www.cplusplus.comclasse istreamclasse ostreamclasse ifstreamclasse ofstream
https://openclassrooms.com/courses/lecture-et-ecriture-dans-les-fichiers-en-c
420-KAB-LG Programmation orientée par objets 175
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 176
c h a î n e d e c a r a c t è r e s ? \0
string chaine = « chaîne de caractères ?» ;
http://www.cplusplus.com/reference/string/basic_string/
Une suite de caractères qui prennent un sens lorsque regroupés.
En C++: Une variable de type string (objet de classe string)
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 177
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'écrancin >> Nom; // Lecture au clavier
// Affichage d’une chaîne constante suivie de la chaîne lue au claviercout << "Bonjour " << Nom << endl;
}
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 178
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 étapestring Message ( "Entrez votre nom : " );
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 179
Affectation de chaînes de caractères
string Message1( "Message à écraser" );string Message2( "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;
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 180
Affectation de chaînes de caractères
Message1 = Message2; //Affectation
Message1.assign (Message2); //Affectation
OU
basic_string& assign (const basic_string& str,size_type subpos, size_type sublen);
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 181
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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 182
Concaténation de chaînes de caractères
// Déclaration et initialisation de chaînes de caractèresstring 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;
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 183
Concaténation de chaînes de caractères
“+ =” est utilisé afin d’ajouter l’opérande de
droite dans l’opérande de gauche.
Message += "123 ";
Message.append ("123");
OU
basic_string& append (const basic_string& str, size_type subpos, size_type sublen);
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 184
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 méthode at lance une exception si la position est invalide!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 185
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!!
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 186
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++ ).
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 187
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;}
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 188
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.
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 189
Comparaison de chaînes
Les opérateurs:
La méthode:
== != < > <= >=
Chaine1.compare ( Chaine2 );
int compare (const basic_string& str) const;
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 190
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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 191
Comparaison de chaînes
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"
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 192
Échange de contenu entre deux chaînes de caractères
Chaine1.swap( Chaine2 );
string Temp;
Temp = Chaine1;
Chaine1 = Chaine2;
Chaine2 = Temp;
Équivalent à:
void swap (basic_string& str);
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 193
Sous-chaînes de caractères
basic_string substr (size_type pos = 0, size_type len = npos) const;
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.
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.
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 194
Sous-chaînes de caractères
Chaine = "Trois-Rivieres est une belle ville."
cout << Chaine.substr( 6, 8 ) << endl;
Rivieres
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 195
Recherche de caractères dans une chaîne
Retourne la position du début de la première occurrence (dans lesens de la lecture) du mot donné en argument.size_type find (const basic_string& str, size_type pos = 0) const;
Retourne la position du début de la première occurrence (dans lesens inverse de lecture) du mot donné en argument.size_type rfind (const basic_string& str, size_type pos = 0) const;
Retourne la position de la première occurrence de l’un descaractères donné en argument.size_type find_first_of (const basic_string& str, size_type pos = 0) const;
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 196
Recherche de caractères dans une chaîne
Méthode Description
find_last_ofRetourne l’indice de la dernière occurrence de l’un des caractères donnés en argument.
find_first_not_ofRetourne l’indice de la première occurrence d’un caractère différent de ceux donnés en argument.
find_last_not_ofRetourne l’indice de la dernière occurrence d’un caractère différent de ceux donnés en argument.
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 197
Recherche de caractères dans une chaîne
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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 198
Effacer, remplacer et insérer des caractères dans une chaîne
Tronque la chaîne à partir d’un certain indice.basic_string& erase (size_type pos = 0, size_type len = npos);
Remplace une partie de la chaîne par une autre.basic_string& replace (size_type pos, size_type len, const basic_string& str);
Insère une chaîne dans une autre à la position voulue.basic_string& insert (size_type pos, const basic_string& str);
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La classe string
420-KAB-LG Programmation orientée par objets 199
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
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Chapitre 7 – Notions avancées
1. La surcharge des opérateurs2. Les exceptions3. Les attributs et méthodes statiques
420-KAB-LG Programmation orientée par objets 200
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 201
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
} 420-KAB-LG Programmation orientée par objets 202
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
}420-KAB-LG Programmation orientée par objets 203
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 *=
420-KAB-LG Programmation orientée par objets 204
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
} 420-KAB-LG Programmation orientée par objets 205
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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)
420-KAB-LG Programmation orientée par objets 206
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Opérateurs relationnelsint 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 207
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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éthodesurchargeant l’opérateur == ?
3. Quelle est la définition de la fonction globalesurchargeant l’opérateur == ?
420-KAB-LG Programmation orientée par objets 208
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Opérateur d’affectationint 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 209
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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éthodesurchargeant 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 ?
420-KAB-LG Programmation orientée par objets 210
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Opérateur d’insertion de fluxint 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 211
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 ?
420-KAB-LG Programmation orientée par objets 212
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Opérateurs d’incrémentation et de décrémentationint main(){
CBase Base(10);cout << ++Base; // Affiche 11cout << 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 213
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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éthodessurchargeant l’opérateur --
420-KAB-LG Programmation orientée par objets 214
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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) const
CBase& operator=(const CBase &Base);
CBase& operator++();
CBase operator++(int);
420-KAB-LG Programmation orientée par objets 215
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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);
420-KAB-LG Programmation orientée par objets 216
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 217
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Opérateurs ne pouvant pas être surchargés.
.*
::
?:
sizeof
420-KAB-LG Programmation orientée par objets 218
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Référence
https://openclassrooms.com/courses/programmez-avec-le-langage-c/la-surcharge-d-operateurs
420-KAB-LG Programmation orientée par objets 219
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 220420-KAB-LG Programmation orientée par objets 220
La gestion des erreurs et les exceptions
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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!420-KAB-LG Programmation orientée par objets 221
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La gestion des erreurs par codes de retourint CFruit::SetPoids(int Poids){ if(Poids>0)
Poids_=Poids;else
return PoidInvalide; } 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/destructeurs?
420-KAB-LG Programmation orientée par objets 222
Constante numérique
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 223
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 224
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;
elsethrow -1;// ou throw string("Poids invalide");// ou throw CTomate();
}420-KAB-LG Programmation orientée par objets 224
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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.
420-KAB-LG Programmation orientée par objets 225
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 226
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 d’exception lancée
420-KAB-LG Programmation orientée par objets 226
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
420-KAB-LG Programmation orientée par objets 227
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 227
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;}
}420-KAB-LG Programmation orientée par objets 228
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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;
}
420-KAB-LG Programmation orientée par objets 229
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
noexcept (C++11) Une fonction ou une méthode qualifiée par noexcept
ne peut pas lancer d'exception Si la fonction ou la méthode lance une exception, le
programme s'arrête brutalement!
void Fonction1() noexcept {} void Fonction2() noexcept { throw 42; } double MonSqrt(double x) noexcept(sqrt()) { return sqrt(x); }
À utiliser avec précautions!!!
420-KAB-LG Programmation orientée par objets 230
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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
420-KAB-LG Programmation orientée par objets 231
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Les variables statiques Variable qui existe en un seul exemplaire Comme un variable globale, mais
encapsulée dans une classe! Valeur 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
420-KAB-LG Programmation orientée par objets 232
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Déclaration (.h)class CAvecStatiques{public:
int Attrib_;static int Stat_;static const int STATCONST;
};
420-KAB-LG Programmation orientée par objets 233
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 234
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
UtilisationCAvecStatiques X, Y;X.Stat_ = 3; cout << X.Stat_; // affiche 3cout << Y.Stat_; // affiche 3Y.Stat_ = 5; cout << X.Stat_; // affiche 5cout << Y.Stat_; // affiche 5CAvecStatiques::Stat_ = 7;cout << CAvecStatiques::Stat_; // Affiche 7
Il n’est pas nécessaire d’avoir un objet pour accéder à une variable statique!!
420-KAB-LG Programmation orientée par objets 235
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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 d'autres méthodes statiques
Déclarationclass CAvecStatiques
{
public:
static void MethodeStatique();
};420-KAB-LG Programmation orientée par objets 236
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
La méthode statique (suite)void CAvecStatiques::MethodeStatique(){
cout << Stat_;}int main(){
CAvecStatiques X;CAvecStatiques::Stat_ = 9;X.MethodeStatique(); // Affiche 9// Affiche 9CAvecStatiques::MethodeStatique();
}420-KAB-LG Programmation orientée par objets 237
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
Utilisation typique: Le compteur d’instances
// Lapin.hclass CLapin{
static int NbLapins_;public:
Clapin::Clapin() { NbLapins++; }Clapin::~Clapin() { NbLapins--; }static int GetNbLapins() { return NbLapins_; }
};
420-KAB-LG Programmation orientée par objets 238
// Lapin.cppint CLapin::NbLapins_ = 0;
// main.cppint main() {
CLapin A,B,C;// Affiche 3cout << Clapin::GetNbLapins();
}
420-KAB-LG Programmation orientée par objets Hiver 2013
Collège Lionel-Groulx Préparé par Joan S. Morales et Etienne Forest
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()
420-KAB-LG Programmation orientée par objets 239
Top Related