C++ 重载类成员访问运算符 -> - C++ 基础教程

C++ 允许重载类成员访问运算符 ( -> )，用于为一个类赋予 "指针" 行为

运算符 -> 必须是一个成员函数

如果使用了 -> 运算符，返回类型必须是指针或者是类的对象

运算符 -> 通常与指针引用运算符 * 结合使用，用于实现 智能指针 的功能

这些指针是行为与正常指针相似的对象，唯一不同的是，通过指针访问对象时，它们会执行其它的任务

比如，当指针销毁时，或者当指针指向另一个对象时，会自动删除对象

间接引用运算符 -> 可被定义为一个一元后缀运算符，比如

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

类 Ptr 的对象可用于访问类 X 的成员，使用方式与指针的用法十分相似

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

语句 p->m 被解释为 (p.operator->())->m

/**
 * file: main.cpp
 * author: 简单教程(www.twle.cn)
 *
 * Copyright © 2015-2065 www.twle.cn. All rights reserved.
 */


#include <iostream>
#include <vector>

// 假设一个实际的类
class Obj {

    static int i, j;

public:

    void f() const { std::cout << i++ << std::endl; }
    void g() const { std::cout << j++ << std::endl; }
};

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

// 为上面的类实现一个容器
class ObjContainer {

    std::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]) {
            std::cout << "Zero value";
            return (Obj*)0;
        }

        return oc.a[index];
    }
};

int main() 
{
    const int sz = 6;

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

编译和运行以上范例，输出结果如下