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

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

INF1101 Algorithmes et structures de données1 Cours 2 Les classes et les objets (suite)

Présentations similaires


Présentation au sujet: "INF1101 Algorithmes et structures de données1 Cours 2 Les classes et les objets (suite)"— Transcription de la présentation:

1 INF1101 Algorithmes et structures de données1 Cours 2 Les classes et les objets (suite)

2 INF1101 Algorithmes et structures de données2 Plan du cours 2 I.Objets et membres constants II.Pointeur this III.Surcharge d’opérateurs IV.Membres statiques

3 INF1101 Algorithmes et structures de données3 I. Objets et membres constants •Mot clé const •Mot clé du langage spécifiant qu’aucune modification d’un objet, d’une variable ou d’un pointeur n’est permise. •La signification du const dans la signature d’une fonction membre d’une classe dépend de sa position.

4 INF1101 Algorithmes et structures de données4 const (suite) •Attribut: la valeur est constante, fixée à la création de l’objet. •Fonction membre const : ne modifie pas l’objet courant, peut seulement accéder à l’information. •Objet const : appel seulement de fonctions membres const.

5 INF1101 Algorithmes et structures de données5 Attribut constant Question: Comment initialiser un attribut constant? Réponse: Par le biais d’une liste d’initialisation class C { public: C() ;...private: const int x;...};C::C() :x(0) :x(0){......}

6 INF1101 Algorithmes et structures de données6 II. Le pointeur this Le mot this est un mot réservé contenant l’adresse de l’objet courant. Ce pointeur sert, entre autres, à retourner une référence à cet objet pour les appels en cascade. ex: a = b = c = d; Il ne faut jamais retourner une référence à une variable locale.

7 INF1101 Algorithmes et structures de données7 II - Surcharges d’opérateurs •Surcharge des opérateurs binaires, unaires, opérateur assignation •Commutativité et fonctions globales

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

9 INF1101 Algorithmes et structures de données9 •En C/C++, il existe des variables de types simples int, float, double, sur lesquelles on peut effectuer des opérations arithmétiques. •En C/C++, il n’existe aucun type de base string, d’où le besoin de créer une classe string pour traiter les chaînes de caractères. •Cette classe string posséderait tous les opérateurs définis pour un type tel que un entier ou un double (+, [], +=, etc). Besoin de la surcharge d’opérateurs

10 INF1101 Algorithmes et structures de données10 Application de la surcharge d’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 à l’utilisation de la surcharge des opérateurs + et [] pour la classe string.

11 INF1101 Algorithmes et structures de données11 Surcharges d’opérateurs •Consiste à redéfinir la fonctionnalité d’un opérateur tel que +, -, ou += pour une classe. •Il faut bien comprendre le fonctionnement de l’opérateur. •L’ordre de priorité est conservé. •L’objet est toujours l’opérande de gauche. •Les opérateurs gardent leur nombre de paramètres et ne peuvent avoir de paramètres par défaut. ( opérateurs binaires et unaires) •Il n’est pas possible de créer de nouveaux opérateurs.

12 INF1101 Algorithmes et structures de données12 Surcharges d’opérateurs Pouvant être surchargés + - * / % ^ & | [] () ~ = += -= *= /= %= ^= &= ! >, >> = \= || >= == new delete. :: ?: sizeof Ne pouvant être surchargés

13 INF1101 Algorithmes et structures de données13 Surcharges d’opérateurs binaires •Opérateur à deux opérandes. •Il doit y avoir une opérande à gauche et à droite du symbole de l’opérateur.

14 INF1101 Algorithmes et structures de données14 Opérateurs binaires string S1(“allo”), S2(“le monde”), S3; S3 = S1+S2; // équivalent à S1.operator+(S2); •operator+() est une fonction membre de la classe string, car S1 est un objet de la classe string. •Retourne un objet string.

15 INF1101 Algorithmes et structures de données15 La classe string : string.h class string { public: public: // Constructeurs string(char ch); string (const char* cstring=“”); ~string() {delete [] buffer}; ~string() {delete [] buffer}; // Opérations... string operator + (const string&) const; private: private: int strLength; int bufferLength char *buffer;...

16 INF1101 Algorithmes et structures de données16 Implémentation de l’opérateur + de string string string::operator+(const string &cstr) const { string Concat; Concat = *this; // surcharge de l’opérateur = Concat += cstr; // surcharge de l’opérateur += return Concat; } Remarque: l’opérateur + est défini en fonction de l’opérateur +=

17 INF1101 Algorithmes et structures de données17 Implémentation de l’opérateur + de string (suite) Que se passe-t-il ? string S1(“allo”), S2; S2 = S1 + ”tous”; // ici il y a une conversion // implicite qui est réalisée // implicite qui est réaliséeS1.operator+(“tous”); Conversion implicite: •On s’attend à une opérande de type string •On a une opérande de type char* •Il existe un constructeur qui accepte ce type de paramètre •On construira donc un objet de type string en lui passant la chaîne •On pourra alors appliquer l’opérateur aux deux opérandes

18 INF1101 Algorithmes et structures de données18 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=“”); on pourra empêcher la construction d’un string dans les cas suivants: string S1, S2; S = “allo”; S = “allo”; S2 = S1 + “allo”

19 INF1101 Algorithmes et structures de données19 Implémentation de l’opérateur + de string (suite) S2 = S1 + “allo” •Si on déclare le constructeur explicit, l’instruction S2 = S1 + “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:

20 INF1101 Algorithmes et structures de données20 Implémentation de l’opérateur + de string (suite) class string { public: public: // Constructeurs explicit string(char ch); explicit string (const char* cstring=“”); ~string() {delete [] buffer}; // Opérations... string operator + (const string&) const; string operator + (const char* cstr) const; string operator + (const char* cstr) const; private: private: int strLength; int bufferLength; char *buffer;...

21 INF1101 Algorithmes et structures de données21 Commutativité et fonctions globales •Ces derniers exemples de l’opérateur + prennent comme supposition que l’opérateur de gauche est un objet string. •Cependant, ceci n’implique pas que cet opérateur est commutatif

22 INF1101 Algorithmes et structures de données22 Opérateur + non commutatif string S1(“allo”), F2(“le monde”), F3; char* A = “tous”; S3 = S1 + A; // équivalent à S1.operator+(A); Cet exemple utilise la surcharge: string operator + (const char*) const; Mais S3 = A + S1; //équivalent à A.operator+(S1)???

23 INF1101 Algorithmes et structures de données23 Commutativité et fonctions globales (suite) •Si l’on désire définir des opérateurs qui accepte autre chose qu’un objet string à gauche, et un objet string à droite de l’opérateur, il faut se définir des fonctions globales pour permettre cette commutativité. Exemple de surcharge globale de type char + string : string operator+(const char* A, const string& B);

24 INF1101 Algorithmes et structures de données24 Commutativité et fonctions globales (suite) Remarque : Si on définit l’opérateur + comme un opérateur global, et qu’on exclut pas la conversion implicite à partir d’un char* lors de l’appel du constructeur, on pourrait se contenter d’une seule définition: string operator+(const string& A, const string& B); string operator+(const string& A, const string& B);

25 INF1101 Algorithmes et structures de données25 Fonctions amies Problè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 &);

26 INF1101 Algorithmes et structures de données26 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

27 INF1101 Algorithmes et structures de données27 Surcharges d’opérateurs unaires •Opérateur ayant un seul paramètre. •L’unique argument est implicitement l’objet lui-même. Rational& operator ++ (); Rational& Rational::operator ++ () {numer+=denom; return (*this); Exemple d’utilisation: Rational F(2,3); F++;}

28 INF1101 Algorithmes et structures de données28 Surcharges de l’opérateur d’assignation (=) •Si l’opérateur = n’est pas surchargé, le compilateur en génère un automatiquement. Cependant, l’assignation se fait attribut par attribut. •L’opérateur = par défaut peut causer de sérieux problèmes si l’objet contient des membres construits par allocation dynamique.

29 INF1101 Algorithmes et structures de données29 Fonctions membres par défaut Dans une classe, même si le programmeur ne les définit pas, il y a toujours: •Un constructeur par défaut s’il n’existe aucun autre constructeur. •Un constructeur de recopie (attribut par attribut) •La surcharge de l’opérateur = par défaut( attribut par attribut) est créée si une instruction fait appel à cet opérateur. •Un destructeur par défaut

30 INF1101 Algorithmes et structures de données30 Attention ! Si votre classe a un attribut qui est un pointeur et alloue de l’espace mémoire dynamiquement, il faut absolument définir: •Un constructeur de recopie; •L’opérateur =; •Et un destructeur; Et surtout ne pas utiliser les fonctions par défaut.

31 INF1101 Algorithmes et structures de données31 Exemple de surcharge d’opérateur = et de constructeur copie Dans la classe string, on a retiré le constructeur copie et la surcharge de l’opérateur = class string { public: string(char ch); string(const char*=“”); ~string();... private: char *buffer; int length; };

32 INF1101 Algorithmes et structures de données32 Exemple de surcharge d’opérateur = string a(“hola”),b; b=a; a buffer length=4; hola0b buffer length=4;

33 INF1101 Algorithmes et structures de données33 Exemple de surcharge 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; }

34 INF1101 Algorithmes et structures de données34 IV – Membre statique •Un attribut static n’existe qu’en une seule copie pour tous les objets d’une classe. •Un attribut static est un espace commun à tous les objets instanciés. •L’espace mémoire d’une variable de classe existe même si aucun objet n’a été déclaré. •Cette variable est accessible via les fonctions membres ou 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 constructeur…

35 INF1101 Algorithmes et structures de données35 Fonction de classe static •Une fonction de classe static ne peut accéder qu’aux membres static d’une classe. •On peut appeler une fonction de classe sans déclarer d’objet par l’opérateur de résolution de portée ::. •Les règles d’encapsulation demeurent les mêmes.

36 INF1101 Algorithmes et structures de données36 Variable de classe et fonction de classe statiques La classe Sphere possède la variable static nbSphere, qui conserve La classe Sphere possède la 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{ public:... static int getNbSphere() {return nbSphere;};...public:... static int nbSphere;... }; }; // Initialisation dans sphere.cpp int Sphere::nbSphere = 0; Fonction de classe


Télécharger ppt "INF1101 Algorithmes et structures de données1 Cours 2 Les classes et les objets (suite)"

Présentations similaires


Annonces Google