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

C ++ surcharge de la fonction et la surcharge des opérateurs

l'accès des membres de classe opérateur (->) peut être surchargé, mais il est lourd. Il est défini pour une classe donnée comportement "pointeur". Opérateur -> doit être une fonction de membre. Si vous utilisez l'opérateur ->, le type de retour doit être un pointeur ou une classe d'objets.

Opérateur -> est habituellement un opérateur de déréférencement de pointeur * utilisé en combinaison avec, pour atteindre la fonction "pointeur intelligent". Ces pointeurs sont des pointeurs se comportent comme des objets normaux, la seule différence est que lorsque vous passez un pointeur pour accéder à l'objet, ils effectuent d'autres tâches. Par exemple, lorsque le pointeur est détruit, ou quand un pointeur vers un autre objet, l'objet sera automatiquement supprimé.

opérateur de référence indirecte -> il peut être défini comme un opérateur de postfix unaire. Autrement dit, une classe donnée:

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

classePtr d'objets peut être utilisé pour accéder à un membre de la classe X,utilisez l'utilisation du pointeur est très similaire. Par exemple:

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

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

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

// 假设一个实际的类
class Obj {
   static int i, j;
public:
   void f() const { cout << i++ << endl; }
   void g() const { cout << j++ << endl; }
};

// 静态成员定义
int Obj::i = 10;
int Obj::j = 12;

// 为上面的类实现一个容器
class ObjContainer {
   vector<Obj*> a;
public:
   void add(Obj* obj)
   { 
      a.push_back(obj);  // 调用向量的标准方法
   }
   friend class SmartPointer;
};

// 实现智能指针，用于访问类 Obj 的成员
class SmartPointer {
   ObjContainer oc;
   int index;
public:
   SmartPointer(ObjContainer& objc)
   { 
       oc = objc;
       index = 0;
   }
   // 返回值表示列表结束
   bool operator++() // 前缀版本
   { 
     if(index >= oc.a.size()) return false;
     if(oc.a[++index] == 0) return false;
     return true;
   }
   bool operator++(int) // 后缀版本
   { 
      return 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); // 创建一个迭代器
   do {
      sp->f(); // 智能指针调用
      sp->g();
   } while(sp++);
   return 0;
}

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

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

C ++ surcharge de la fonction et la surcharge des opérateurs