Operador de acesso de membro de classe (->) Sobrecarga em C ++

O operador de acesso do membro da classe (->) pode estar sobrecarregado, mas é um pouco mais complicado. É definido para dar a um tipo de classe um comportamento "semelhante a um ponteiro". O operador -> deve ser uma função de membro. Se usado, seu tipo de retorno deve ser um ponteiro ou um objeto de uma classe à qual você pode aplicar.

O operador-> é freqüentemente usado em conjunto com o operador de desreferência de ponteiro * para implementar "ponteiros inteligentes". Esses ponteiros são objetos que se comportam como ponteiros normais, exceto que executam outras tarefas quando você acessa um objeto por meio deles, como exclusão automática de objeto quando o ponteiro é destruído ou quando é usado para apontar para outro objeto.

O operador de desreferenciação-> pode ser definido como um operador postfix unário. Ou seja, dada uma aula -

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

Objetos de aula Ptr pode ser usado para acessar os membros da classe Xde uma maneira muito semelhante à forma como os ponteiros são usados. Por exemplo -

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

A declaração p-> m é interpretada como (p.operador -> ()) -> m. Usando o mesmo conceito, o exemplo a seguir explica como um operador de acesso de classe -> pode ser sobrecarregado.

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

// Consider an actual class.
class Obj {
   static int i, j;
   
public:
   void f() const { cout << i++ << endl; }
   void g() const { cout << j++ << endl; }
};

// Static member definitions:
int Obj::i = 10;
int Obj::j = 12;

// Implement a container for the above class
class ObjContainer {
   vector<Obj*> a;

   public:
      void add(Obj* obj) { 
         a.push_back(obj);  // call vector's standard method.
      }
      friend class SmartPointer;
};

// implement smart pointer to access member of Obj class.
class SmartPointer {
   ObjContainer oc;
   int index;
   
   public:
      SmartPointer(ObjContainer& objc) { 
         oc = objc;
         index = 0;
      }
   
      // Return value indicates end of list:
      bool operator++() { // Prefix version 
         if(index >= oc.a.size()) return false;
         if(oc.a[++index] == 0) return false;
         return true;
      }
   
      bool operator++(int) { // Postfix version 
         return operator++();
      }
   
      // overload operator->
      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); // Create an iterator
   do {
      sp->f(); // smart pointer call
      sp->g();
   } while(sp++);
   
   return 0;
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

↰ Previous page