C++ Surcharge de l'opérateur d'accès aux membres de classe ->

Surcharge des opérateurs et surcharge des fonctions en C++

L'opérateur d'accès aux membres de classe (->) peut être surchargé, mais c'est plutôt problématique. Il est défini pour donner à une classe un comportement de « pointeur ». L'opérateur -> doit être une fonction membre. Si l'opérateur -> est utilisé, le type de retour doit être un pointeur ou un objet de classe.

L'opérateur -> est généralement utilisé en combinaison avec l'opérateur de déréférencement de pointeur * pour implémenter la fonctionnalité de « pointeur intelligent ». Ces pointeurs sont des objets qui se comportent comme des pointeurs normaux, sauf que lorsque vous accédez à un objet via le pointeur, ils effectuent d'autres tâches. Par exemple, lorsque le pointeur est détruit, ou lorsque le pointeur pointe vers un autre objet, l'objet est automatiquement supprimé.

L'opérateur de déréférencement -> peut être défini comme un opérateur unaire postfixe. C'est-à-dire, étant donné une classe :

class Ptr{
   //...
   X * operator->();
};

ClassPtrLes objets peuvent être utilisés pour accéder aux classes.XSes membres sont utilisés d'une manière très similaire aux pointeurs. Par exemple :

void f(Ptr p )
{
   p->m = 10 ; // (p.operator->())->m = 10
}

L'instruction p->m est interprétée comme (p.operator->())->m. De même, l'exemple suivant montre comment surcharger l'opérateur d'accès aux membres de classe ->.

Exemple

#include <iostream> #include <vector> using namespace std; // Supposons une classe réelle class Obj { static int i, j; public: void f() const { cout << i++ << endl; } void g() const { cout << j++ << endl; } }; // Définition de membre statique int Obj::i = 10; int Obj::j = 12; // Implémenter un conteneur pour la classe ci-dessus class ObjContainer { vector<Obj*> a; public: void add(Obj* obj) { a.push_back(obj); // Appeler les méthodes standard du vector } friend class SmartPointer; }; // Implémenter un pointeur intelligent pour accéder aux membres de la classe Obj class SmartPointer { ObjContainer oc; int index; public: SmartPointer(ObjContainer& objc) { oc = objc; index = 0; } // La valeur de retour indique la fin de la liste bool operator++() // Version préfixée { if(index >= oc.a.size() - 1) return false; if(oc.a[++index] == 0) return false; return true; } bool operator++(int) // Version suffixe { return operator++(); } // Surcharge de l'opérateur -> Obj* operator->() const { if(!oc.a[index]) { cout << "Zero value"; return (Obj*)0; } return oc.a[index]; } }; int main() { const int sz = 10; Obj o[sz]; ObjContainer oc; for(int i = 0; i < sz; i++) { oc.add(&o[i]); } SmartPointer sp(oc); // Un itérateur do { sp->f(); // Appel de pointeur intelligent sp->g(); } while(sp++); return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants :

10
12
11
13
12
14
13
15
14
16
15
17
16
18
17
19
18
20
19
21

Surcharge des opérateurs et surcharge des fonctions en C++

autres extensions