能否重载成员访问操作符以检测任意成员变量的修改？

首先明确：C++里不能重载.成员访问操作符，这是语法规则明确禁止的。但可以通过代理类配合->重载，或者给成员变量套一层代理的方式，实现你要的「任意成员被修改时自动设置flag」的需求，完全不用写一堆setter。

核心思路：用代理类包装成员变量 #

给每个需要监控的成员变量套一个代理模板类，这个代理类会持有原始值的引用，以及指向flag的指针。当代理类被赋值时，自动触发flag = true的操作。同时代理类支持隐式转换回原始类型，保证读取操作和普通变量一样方便。

具体代码实现 #

#include <iostream>

// 代理模板类，用于监控赋值操作
template<typename T>
class Monitor {
public:
    Monitor(T& val, bool& flag) : m_val(val), m_flag(flag) {}

    // 隐式转换为原始类型，支持读取操作
    operator T() const { return m_val; }

    // 重载赋值运算符，赋值时设置flag
    Monitor<T>& operator=(const T& new_val) {
        if (m_val != new_val) { // 可选：避免无意义的flag设置
            m_val = new_val;
            m_flag = true;
        }
        return *this;
    }

    // 重载其他可能修改值的运算符，比如++、--等（按需添加）
    Monitor<T>& operator++() {
        m_val++;
        m_flag = true;
        return *this;
    }

    T operator++(int) {
        T temp = m_val;
        m_val++;
        m_flag = true;
        return temp;
    }

private:
    T& m_val;
    bool& m_flag;
};

struct foo {
private:
    // 实际存储的原始成员变量
    int m_bar;
    int m_baz;
public:
    bool flag = false;

    // 对外暴露的代理成员，关联到原始变量和flag
    Monitor<int> bar;
    Monitor<int> baz;

    // 构造函数初始化代理
    foo() : bar(m_bar, flag), baz(m_baz, flag) {}
};

// 测试代码
int main() {
    foo f;
    std::cout << "初始flag: " << std::boolalpha << f.flag << std::endl;

    f.bar = 10;
    std::cout << "修改bar后flag: " << f.flag << std::endl;

    f.baz++;
    std::cout << "自增baz后flag: " << f.flag << std::endl;

    // 读取操作不会触发flag
    int val = f.bar;
    std::cout << "读取bar后flag: " << f.flag << std::endl;

    return 0;
}

补充说明 #

• 这种方式不需要给每个成员写setter，所有代理过的成员被修改时都会自动设置flag，代码冗余度极低。
• 可以根据需求给代理类添加更多运算符重载（比如+=、-=等），保证所有修改操作都能被捕获。
• 如果需要支持const对象的访问，要给代理类添加const版本的转换运算符和成员函数。
• 代理类的性能开销极小，几乎可以忽略，适合大多数场景。

关于->重载的替代方案 #

如果你想用->的方式，可以让foo类返回一个代理对象，这个代理对象重载->，返回一个包装后的结构体指针，但这种方式不如直接给成员套代理直观。示例：

struct FooProxy {
    foo* m_ptr;
    FooProxy(foo* ptr) : m_ptr(ptr) {}

    // 重载->，返回一个自定义的结构体指针，里面的成员是代理类型
    struct WrappedFoo {
        foo* m_foo;
        int& bar() { m_foo->flag = true; return m_foo->m_bar; }
        int& baz() { m_foo->flag = true; return m_foo->m_baz; }
    };

    WrappedFoo operator->() { return {m_ptr}; }
};

// 使用时：
FooProxy fp(&f);
fp->bar() = 20; // 此时flag会被设置

不过这种方式需要每次访问成员都调用函数，不如第一种代理类的方式自然。

内容的提问来源于stack exchange，提问作者Rahul Iyer