【C++重载操作符与转换】成员访问操作符

最新推荐文章于 2025-05-05 14:12:43 发布

byte轻骑兵

最新推荐文章于 2025-05-05 14:12:43 发布

阅读量957

点赞数 31

分类专栏： # C++深度探索与实战专栏文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/weixin_37800531/article/details/147692857

版权

C++深度探索与实战专栏专栏收录该内容

67 篇文章

订阅专栏

三、成员指针操作符（.*）和指向成员指针的箭头操作符（->*）

在 C++ 编程中，操作符重载是一项强大的特性，它允许程序员为自定义类型重新定义操作符的行为。成员访问操作符，主要包括 .（点操作符）、->（箭头操作符）和 .*（成员指针操作符）以及 ->*（指向成员指针的箭头操作符），在面向对象编程中起着关键作用。通过重载这些操作符，可以让自定义类的对象表现得像内置类型或标准库容器一样自然和直观。

一、点操作符（`.`）

1.1 基本概念

点操作符（.）用于访问对象的成员，它是 C++ 中最常用的成员访问操作符之一。对于内置类型和自定义类，点操作符可以直接访问对象的成员变量和成员函数。例如：

#include <iostream>

class MyClass {
public:
    int value;
    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.value = 42;
    obj.printValue();
    return 0;
}

使用点操作符访问 MyClass 对象的成员变量 value 和成员函数 printValue。

1.2 点操作符不能被重载

需要注意的是，点操作符（.）不能被重载。这是因为点操作符的第一个操作数必须是对象本身，重载点操作符可能会导致语义混淆，破坏 C++ 的语法规则。例如，无法编写如下代码：

class MyClass {
    // 错误：点操作符不能被重载
    // 返回类型 operator.(const MyClass& other) {
    //     // 实现逻辑
    // }
};

二、箭头操作符（`->`）

2.1 基本概念

箭头操作符（->）通常用于通过指针访问对象的成员。可以看作是解引用操作符（*）和点操作符（.）的组合。例如：

#include <iostream>

class MyClass {
public:
    int value;
    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.value = 42;
    MyClass* ptr = &obj;
    ptr->printValue(); // 等价于 (*ptr).printValue()
    return 0;
}

使用箭头操作符通过指针 ptr 访问 MyClass 对象的成员函数 printValue。

2.2 箭头操作符的重载

箭头操作符可以被重载，这使得我们可以创建智能指针类，让对象表现得像指针一样。箭头操作符重载函数必须返回一个指针或者一个重载了箭头操作符的对象。

代码示例：自定义智能指针

#include <iostream>

template <typename T>
class SmartPtr {
private:
    T* ptr;
public:
    SmartPtr(T* p = nullptr) : ptr(p) {}
    ~SmartPtr() {
        delete ptr;
    }
    T& operator*() {
        return *ptr;
    }
    T* operator->() {
        return ptr;
    }
};

class MyClass {
public:
    int value;
    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    SmartPtr<MyClass> smartPtr(new MyClass());
    smartPtr->value = 42;
    smartPtr->printValue();
    return 0;
}

定义了一个简单的智能指针类 SmartPtr，并重载了箭头操作符 ->。通过重载箭头操作符，SmartPtr 对象可以像普通指针一样使用。

2.3 箭头操作符重载的特殊规则

箭头操作符重载函数必须返回一个指针或者一个重载了箭头操作符的对象。
如果返回的是指针，编译器会继续使用该指针进行成员访问；如果返回的是一个重载了箭头操作符的对象，编译器会递归调用该对象的箭头操作符重载函数，直到返回一个指针。

三、成员指针操作符（`.`）和指向成员指针的箭头操作符（`->`）

3.1 基本概念

成员指针操作符（.*）和指向成员指针的箭头操作符（->*）用于通过成员指针访问对象的成员。成员指针是一种特殊的指针，它指向类的成员变量或成员函数，而不是对象本身。例如：

#include <iostream>

class MyClass {
public:
    int value;
    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.value = 42;

    // 成员变量指针
    int MyClass::* ptrToValue = &MyClass::value;
    std::cout << "Value: " << obj.*ptrToValue << std::endl;

    // 成员函数指针
    void (MyClass::* ptrToFunction)() = &MyClass::printValue;
    (obj.*ptrToFunction)();

    return 0;
}

使用成员指针操作符（.*）通过成员指针访问 MyClass 对象的成员变量和成员函数。

3.2 成员指针操作符的重载

成员指针操作符（.*）和指向成员指针的箭头操作符（->*）也可以被重载，但这种情况相对较少见。重载这两个操作符可以实现一些高级的编程技巧，如代理类和元编程。

代码示例：简单的代理类

#include <iostream>

// 定义一个简单的类 MyClass，包含一个整型成员变量 value 和一个成员函数 printValue
class MyClass {
public:
    int value;
    void printValue() {
        std::cout << "Value: " << value << std::endl;
    }
};

// 定义代理类 Proxy，用于包装 MyClass 对象
class Proxy {
private:
    MyClass* obj;
public:
    // 构造函数，接收一个 MyClass 对象的指针
    Proxy(MyClass* p) : obj(p) {}

    // 实现类似 .* 操作符的功能，通过成员指针访问成员变量
    template <typename T>
    T getMember(T MyClass::* member) {
        return obj->*member;
    }

    // 实现类似 ->* 操作符的功能，通过成员指针调用成员函数
    template <typename T>
    void callMember(T (MyClass::* member)()) {
        (obj->*member)();
    }
};

int main() {
    MyClass obj;
    obj.value = 42;
    // 创建 Proxy 对象，传入 MyClass 对象的地址
    Proxy proxy(&obj);

    // 通过 Proxy 对象的 getMember 函数获取 MyClass 的成员变量值
    int value = proxy.getMember(&MyClass::value);
    std::cout << "Value: " << value << std::endl;

    // 通过 Proxy 对象的 callMember 函数调用 MyClass 的成员函数
    proxy.callMember(&MyClass::printValue);

    return 0;
}