类成员访问运算符(- >)可以被重载，但它较为麻烦。它被定义为一个类类型的一个“类指针”行为。操作符 ->必须是一个成员函数。如果使用，它的返回类型必须为指针或一个类的对象，才可以适用。

在操作符 ->常用于与指针引用操作符*结合实施“智能指针”。这些指针是行为像正常指针除了它们执行其它任务时，通过它们访问对象的对象，如自动对象删除或者当指示器被破坏，或者指针用于指向另一个对象。

反引用操作符 ->可以被定义为一个一元后缀运算符。也就是说，给出一个类：

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

类的Ptr对象可以被用于访问在一个非常类似的方式类X的成员的指针的使用方式。例如：

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

声明p->m 被解释为(p.operator->())->m。下面的例子使用相同的概念，说明如何一个类接入运算符->可以被重载。

#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 SmartYiibaier;
};

// implement smart yiibaier to access member of Obj class.
class SmartYiibaier {
   ObjContainer oc;
   int index;
public:
   SmartYiibaier(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]);
   }
   SmartYiibaier sp(oc); // Create an iterator
   do {
      sp->f(); // smart yiibaier call
      sp->g();
   } while(sp++);
   return 0;
}

让我们编译和运行上面的程序，这将产生以下结果：

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

纠错/补充 收藏