inf1101 algorithmes et structures de données1 cours 2 les classes et les objets (suite)

INF1101 Algorithmes et structures de données

1

Cours 2Cours 2

Les classes et les objetsLes classes et les objets(suite)(suite)

INF1101 Algorithmes et structures de données 2

Plan du cours 2Plan du cours 2

I.I. Objets et membres constantsObjets et membres constantsII.II. Pointeur Pointeur thisthisIII.III. Surcharge d’opérateursSurcharge d’opérateursIV.IV. Membres statiquesMembres statiques


I. Objets et membres I. Objets et membres constantsconstants

• Mot clé Mot clé constconst• Mot clé du langage spécifiant Mot clé du langage spécifiant

qu’aucune modification d’un objet, qu’aucune modification d’un objet, d’une variable ou d’un pointeur n’est d’une variable ou d’un pointeur n’est permise.permise.

• La signification du La signification du constconst dans la dans la signature d’une fonction membre signature d’une fonction membre d’une classe dépend de sa position.d’une classe dépend de sa position.


const (suite)const (suite)

• Attribut: la valeur est constante, fixée à la Attribut: la valeur est constante, fixée à la création de l’objet.création de l’objet.

• Fonction membre Fonction membre constconst : ne modifie pas : ne modifie pas l’objet courant, peut seulement accéder à l’objet courant, peut seulement accéder à l’information.l’information.

• Objet Objet constconst: appel seulement de fonctions : appel seulement de fonctions membres const.membres const.


Attribut constantAttribut constantQuestion: Question: Comment initialiser un attribut constant?Comment initialiser un attribut constant?Réponse: Réponse: Par le biais d’une liste d’initialisationPar le biais d’une liste d’initialisation

class C {class C {public:public:

C() ;C() ;......

private:private:const int x;const int x;......

};};

C::C() C::C() :x(0) :x(0) {{ ......}}


II. Le pointeur thisII. Le pointeur this

Le mot Le mot thisthis est un mot réservé contenant est un mot réservé contenant l’adresse de l’objet courant.l’adresse de l’objet courant.

Ce pointeur sert, entre autres, à retourner Ce pointeur sert, entre autres, à retourner une référence à cet objet pour les appels en une référence à cet objet pour les appels en cascade.cascade.ex: ex: a = b = c = d;a = b = c = d;

Il ne faut jamais retourner une référence à Il ne faut jamais retourner une référence à une variable locale.une variable locale.


II - II - Surcharges Surcharges d’opérateursd’opérateurs

• Surcharge des opérateurs binaires, Surcharge des opérateurs binaires, unaires, opérateur assignationunaires, opérateur assignation

• CommutativitéCommutativité et fonctions globales et fonctions globales


IntroductionIntroduction

La surcharge (ou surdéfinition)La surcharge (ou surdéfinition) d’opérateur est un concept qui d’opérateur est un concept qui permet d’implémenter une fonction permet d’implémenter une fonction ou un opérateur de différentes ou un opérateur de différentes façons sans en changer la méthode façons sans en changer la méthode d’appel (signature).d’appel (signature).


• En C/C++, il existe des variables de types simples En C/C++, il existe des variables de types simples intint, , floatfloat, , doubledouble, sur lesquelles on peut , sur lesquelles on peut effectuer des opérations arithmétiques.effectuer des opérations arithmétiques.

• En C/C++, il n’existe aucun type de base En C/C++, il n’existe aucun type de base stringstring, , d’où le besoin de créer une classe d’où le besoin de créer une classe stringstring pour pour traiter les chaînes de caractères.traiter les chaînes de caractères.

• Cette classe Cette classe stringstring posséderait tous les posséderait tous les opérateurs définis pour un type tel que un entier opérateurs définis pour un type tel que un entier ou un double (+, [], +=, etc). ou un double (+, [], +=, etc).

Besoin de la surcharge Besoin de la surcharge d’opérateurs d’opérateurs


Application de la surcharge Application de la surcharge d’opérateursd’opérateurs

string S1(“allo ”), S2(“le monde”), S3;

S3 = S1 + S2;

S3 = S1 + “a tous”;

S2[1] = ‘a’;

S2[3] = ‘r’;

Cet exemple est rendu possible grâce à Cet exemple est rendu possible grâce à l’utilisation de la surcharge des opérateurs l’utilisation de la surcharge des opérateurs + et [] pour la classe + et [] pour la classe stringstring..


Surcharges d’opérateursSurcharges d’opérateurs• Consiste à redéfinir la fonctionnalité d’un opérateur tel que +, Consiste à redéfinir la fonctionnalité d’un opérateur tel que +,

-, ou += pour une classe.-, ou += pour une classe.

• Il faut bien comprendre le fonctionnement de l’opérateur.Il faut bien comprendre le fonctionnement de l’opérateur.

• L’ordre de priorité est conservé.L’ordre de priorité est conservé.

• L’objet est toujours l’opérande de gauche. L’objet est toujours l’opérande de gauche.

• Les opérateurs gardent leur nombre de paramètres et ne Les opérateurs gardent leur nombre de paramètres et ne peuvent avoir de paramètres par défaut. ( opérateurs binaires peuvent avoir de paramètres par défaut. ( opérateurs binaires et unaires)et unaires)

• Il n’est pas possible de créer de nouveaux opérateurs.Il n’est pas possible de créer de nouveaux opérateurs.


Surcharges d’opérateursSurcharges d’opérateurs

Pouvant être surchargés

+ - * / % ^ & | [] () ~ = < > += -= *= /= %= ^= &= ! ++ -- -> ,>> << && != <= >= \= || <<= >>= ==new delete

. :: ?: sizeof

Ne pouvant être surchargés


Surcharges d’opérateurs Surcharges d’opérateurs binairesbinaires

• Opérateur à deux opérandes.Opérateur à deux opérandes.

• Il doit y avoir une opérande à gauche Il doit y avoir une opérande à gauche et à droite du symbole de l’opérateur.et à droite du symbole de l’opérateur.


Opérateurs binairesOpérateurs binairesstring S1(“allo”), S2(“le monde”), S3;string S1(“allo”), S2(“le monde”), S3;

S3 = S1+S2; // équivalent à S1.operator+(S2);S3 = S1+S2; // équivalent à S1.operator+(S2);

• operator+()operator+() est une fonction est une fonction membre de la classe membre de la classe stringstring, car S1 , car S1 est un objet de la classe est un objet de la classe stringstring..

• Retourne un objet Retourne un objet stringstring..


La classe string : string.hLa classe string : string.h

class stringclass string{{ public:public:

// Constructeurs// Constructeurs

string(char ch);string(char ch);string (const char* cstring=“”);string (const char* cstring=“”);

~string() {delete [] buffer};~string() {delete [] buffer};

// Opérations// Opérations......

string operator + (const string&) const;string operator + (const string&) const; private:private:

int strLength;int strLength;

int bufferLengthint bufferLength

char *buffer;char *buffer;

......


Implémentation de Implémentation de l’opérateur + de string l’opérateur + de string

string string::operator+(const string &cstr) conststring string::operator+(const string &cstr) const{{

string Concat;string Concat;

Concat = *this; // surcharge de l’opérateur =Concat = *this; // surcharge de l’opérateur =

Concat += cstr; // surcharge de l’opérateur +=Concat += cstr; // surcharge de l’opérateur +=

return Concat;return Concat;}}

Remarque: l’opérateur + est défini en fonction de l’opérateur +=


Implémentation de l’opérateur + de string (suite)

Que se passe-t-ilQue se passe-t-il ? ?

string S1(“allo”), S2;string S1(“allo”), S2;S2 = S1 + ”tous”; // ici il y a une conversion S2 = S1 + ”tous”; // ici il y a une conversion // implicite qui est réalisée// implicite qui est réaliséeS1.operator+(“tous”);S1.operator+(“tous”);

Conversion implicite: Conversion implicite: • On s’attend à une opérande de type On s’attend à une opérande de type stringstring• On a une opérande de typeOn a une opérande de type char* char*• Il existe un constructeur qui accepte ce type de paramètreIl existe un constructeur qui accepte ce type de paramètre• On construira donc un objet de type On construira donc un objet de type stringstring en lui passant la en lui passant la

chaîne chaîne • On pourra alors appliquer l’opérateur aux deux opérandesOn pourra alors appliquer l’opérateur aux deux opérandes


Conversion implicite de type• Il faut se méfier des conversions implicites, C++ peut en

faire à des endroits où on ne s’y attend pas• On peut empêcher qu’un objet soit créé par une conversion

implicite: il suffit d’ajouter explicit avant la déclaration du constructeur

• Ainsi, si on déclare le constructeur de la manière suivante:

explicit string (const char* cstring=“”);explicit string (const char* cstring=“”);

on pourra empêcher la construction d’un string dans les cas on pourra empêcher la construction d’un string dans les cas suivants:suivants:

string S1, S2;string S1, S2; S = “allo”;S = “allo”;

S2 = S1 + “allo”S2 = S1 + “allo”


Implémentation de Implémentation de l’opérateur + de string l’opérateur + de string (suite)(suite)

• Si on déclare le constructeur explicit, l’instruction S2 = S1 + S2 = S1 + “allo”“allo” n’est plus acceptée parce que l’opérateur n’accepte que des opérandes de type string.

• Dans ce cas, pour que l’instruction soit valide, il faut ajouter une autre définition de l’opérateur:


Implémentation de Implémentation de l’opérateur + de string l’opérateur + de string (suite)(suite)

class stringclass string{{ public:public:

// Constructeurs// Constructeurs

explicit string(char ch);explicit string(char ch);explicit string (const char* cstring=“”);explicit string (const char* cstring=“”);

~string() {delete [] buffer};~string() {delete [] buffer};

// Opérations// Opérations......string operator + (const string&) const;string operator + (const string&) const;

string operator + (const char* cstr) const;string operator + (const char* cstr) const; private:private:

int strLength;int strLength;

int bufferLength;int bufferLength;

char *buffer;char *buffer;......


Commutativité et Commutativité et fonctions globalesfonctions globales

• Ces derniers exemples de l’opérateur Ces derniers exemples de l’opérateur + prennent comme supposition que + prennent comme supposition que l’opérateur de gauche est un objet l’opérateur de gauche est un objet stringstring. .

• Cependant, ceci n’implique pas que Cependant, ceci n’implique pas que cet opérateur est commutatif cet opérateur est commutatif


Opérateur + non Opérateur + non commutatifcommutatif

string S1(“allo”), F2(“le monde”), F3;string S1(“allo”), F2(“le monde”), F3;

char* A = “tous”;char* A = “tous”;

S3 = S1 + A; // équivalent à S1.operator+(A);S3 = S1 + A; // équivalent à S1.operator+(A);

Cet exemple utilise la surcharge:Cet exemple utilise la surcharge:

string operator + (const char*) const;string operator + (const char*) const;

MaisMais

S3 = A + S1; S3 = A + S1; //équivalent à A.operator+(S1)???//équivalent à A.operator+(S1)???


Commutativité et fonctions globales (suite)

• Si l’on désire définir des opérateurs qui Si l’on désire définir des opérateurs qui accepte autre chose qu’un objet accepte autre chose qu’un objet stringstring à à gauche, et un objet gauche, et un objet stringstring à droite de à droite de l’opérateur, il faut se définir des l’opérateur, il faut se définir des fonctions fonctions globales globales pour permettre cette pour permettre cette commutativité.commutativité.

Exemple de surcharge globale de type Exemple de surcharge globale de type char + stringchar + string::string operator+(const char* A, const string& B);string operator+(const char* A, const string& B);


Commutativité et fonctions globales (suite)

RemarqueRemarque::

Si on définit l’opérateur + comme un opérateur Si on définit l’opérateur + comme un opérateur global, et qu’on exclut pas la conversion implicite global, et qu’on exclut pas la conversion implicite à partir d’un à partir d’un char* char* lors de l’appel du lors de l’appel du constructeurconstructeur,, on pourrait se contenter d’une on pourrait se contenter d’une seule définition:seule définition:

string operator+(const string& A, const string& B);string operator+(const string& A, const string& B);


Fonctions amiesProblème dans certains cas:

La fonction globale n’a pas le droit d’accéder au données privées de la classe

Solutions:• L’opérateur global accède aux données privées

par le bien de fonctions membres publiques (peut être inefficace dans certains cas)

• On déclare la fonction globale comme étant « amie »friend string operator +(char*, const string &);


Fonctions amies (suite)• Attention: les fonctions amies violent le principe

d’encapsulation. À moins de ne pouvoir faire autrement, il vaut mieux les éviter

• Dans le cas de la classe string, on peut l’éviter, en définissant une fonction globale qui prend en paramètre deux objets de type string:string operator+(const string&, const string&);

• Dans ce cas, il faut bien entendu que le constructeur accepte la conversion implicite

• Dans certains cas, on peut éviter de déclarer une fonction amie en n’utilisant que des fonctions membres de la classe pour accéder aux attributs de l’objet, si elles sont suffisantes pour la définition de l’opérateur


Surcharges d’opérateurs Surcharges d’opérateurs unairesunaires

• Opérateur ayant un seul paramètre.Opérateur ayant un seul paramètre.• L’unique argument est implicitement l’objet lui-L’unique argument est implicitement l’objet lui-

même.même.Rational& operator ++ (); Rational& operator ++ ();

Rational& Rational::operator ++ () Rational& Rational::operator ++ () {{

numer+=denom;numer+=denom;

return (*this);return (*this); Exemple dExemple d’utilisation:’utilisation:Rational F(2,3);Rational F(2,3);F++;F++;

}}


Surcharges de Surcharges de l’opérateur d’assignation l’opérateur d’assignation (=)(=)• Si l’opérateur = n’est pas surchargé, le Si l’opérateur = n’est pas surchargé, le

compilateur en génère un compilateur en génère un automatiquement. Cependant, l’assignation automatiquement. Cependant, l’assignation se fait attribut par attribut.se fait attribut par attribut.

• L’opérateur = par défaut peut causer de L’opérateur = par défaut peut causer de sérieux problèmes si l’objet contient des sérieux problèmes si l’objet contient des membres construits par allocation membres construits par allocation dynamique.dynamique.


Fonctions membres par Fonctions membres par défautdéfaut

Dans une classe, même si le programmeur Dans une classe, même si le programmeur ne les définit pas, il y a toujours:ne les définit pas, il y a toujours:

• Un Un constructeur par défautconstructeur par défaut s’il n’existe aucun s’il n’existe aucun autre constructeur.autre constructeur.

• Un Un constructeur de recopieconstructeur de recopie (attribut par attribut) (attribut par attribut)• La La surcharge de l’opérateur =surcharge de l’opérateur = par défaut( attribut par défaut( attribut

par attribut) est créée si une instruction fait par attribut) est créée si une instruction fait appel à cet opérateur.appel à cet opérateur.

• Un Un destructeur par défautdestructeur par défaut


Attention !Attention !Si votre classe a un attribut qui est un Si votre classe a un attribut qui est un pointeur et alloue de l’espace mémoire pointeur et alloue de l’espace mémoire dynamiquement, il faut absolument définir:dynamiquement, il faut absolument définir:

• Un constructeur de recopie;Un constructeur de recopie;• L’opérateur =;L’opérateur =;• Et un destructeur;Et un destructeur;

Et surtout ne pas utiliser les fonctions par défaut.Et surtout ne pas utiliser les fonctions par défaut.


Exemple de surcharge Exemple de surcharge d’opérateur d’opérateur = et de constructeur copie= et de constructeur copie

Dans la classe string, on a retiré leDans la classe string, on a retiré leconstructeur copie et la surcharge de l’opérateur =constructeur copie et la surcharge de l’opérateur =

class string{public:

string(char ch);string(const char*=“”);~string();. . .

private:char *buffer;int length;

};


Exemple de surcharge Exemple de surcharge d’opérateur =d’opérateur =

string a(“hola”),b; string a(“hola”),b;

b=a;b=a;

aabuffer

length=4;

h o l a 0

bbbuffer

length=4;


Exemple de surcharge Exemple de surcharge d’opérateur =d’opérateur =

string& string::operator=(const string &rhs){

if( this != &rhs) { if(bufferLength < rhs.length()+1) { delete []buffer; bufferLength=rhs.length()+1; buffer = new char[bufferLength]; } strLength=rhs.length(); strcpy(buffer,rhs.buffer); }

return *this;}


IV – Membre statiqueIV – Membre statique• Un attribut Un attribut static static n’existe qu’en une seule copie pour tous n’existe qu’en une seule copie pour tous

les objets d’une classe. les objets d’une classe.

• Un attribut Un attribut staticstatic est un espace commun à tous les objets est un espace commun à tous les objets instanciés. instanciés.

• L’espace mémoire d’une variable de classe existe même si L’espace mémoire d’une variable de classe existe même si aucun objet n’a été déclaré.aucun objet n’a été déclaré.

• Cette variable est accessible via les fonctions membres ou Cette variable est accessible via les fonctions membres ou par l’entremise de l’opérateur de résolution de portée :: .par l’entremise de l’opérateur de résolution de portée :: .

• L’initialisation d’une variable de classe ne se fait pas dans le L’initialisation d’une variable de classe ne se fait pas dans le constructeur…constructeur…


Fonction de classe staticFonction de classe static

• Une fonction de classe Une fonction de classe staticstatic ne peut ne peut accéder qu’aux membres accéder qu’aux membres staticstatic d’une d’une classe.classe.

• On peut appeler une fonction de classe On peut appeler une fonction de classe sans déclarer d’objet par l’opérateur de sans déclarer d’objet par l’opérateur de résolution de portée :: . résolution de portée :: .

• Les règles d’encapsulation demeurent les Les règles d’encapsulation demeurent les mêmes.mêmes.


Variable de classe et Variable de classe et fonction de classe statiquesfonction de classe statiques

La classe Sphere possèdeLa classe Sphere possède la variable static nbSphere, qui conservela variable static nbSphere, qui conserve le nombre total de sphères créées dans le programme.le nombre total de sphères créées dans le programme.

class Sphere{class Sphere{public:public:

......static int getNbSphere() {return nbSphere;};static int getNbSphere() {return nbSphere;};......

public: public: ......static int nbSphere;static int nbSphere;......

};};

// Initialisation dans sphere.cpp// Initialisation dans sphere.cppint Sphere::nbSphere = 0;int Sphere::nbSphere = 0;

FonctionFonction de classede classe

inf1101 algorithmes et structures de données1 cours 2 les classes et les objets (suite)

Documents