C++中如何在被指向对象变更时触发操作且保持B类函数私有？

你需要的是值变更监听能力，同时规避B类私有方法的public暴露，以下是几个可行的落地方案：

方案1：友元声明（最简实现） #

直接在B类中声明A为友元类，A就可以直接访问B的所有私有成员，无需将目标函数设为public。

class B {
    // 友元声明，仅允许A类访问私有成员
    friend class A;
private:
    double* pVar;
    void onVarChanged() { /* 原有业务逻辑 */ }
public:
    B(double* _var) : pVar(_var) {}
};

class A {
private:
    double var;
    B var2 {&var};
public:
    void setVar(double newVal) {
        if (var != newVal) {
            var = newVal;
            // 直接调用B的私有方法
            var2.onVarChanged();
        }
    }
};

优缺点：实现成本几乎为0，适合A、B本就属于同一内部模块、耦合度较高的场景；缺点是友元会打破一定的封装边界，不适合对外暴露的公共类使用。

方案2：回调注入（低耦合实现） #

B在构造时将自己的私有成员函数包装为匿名回调注入到A中，A只需要在值变更时触发回调，不需要感知B的内部实现，也不需要友元声明。

#include <functional>

class A {
private:
    double var;
    std::function<void()> varChangeCb;
public:
    void setVarChangeCb(std::function<void()> cb) { varChangeCb = std::move(cb); }
    void setVar(double newVal) {
        if (var != newVal) {
            var = newVal;
            if (varChangeCb) varChangeCb();
        }
    }
};

class B {
private:
    double* pVar;
    void onVarChanged() { /* 原有业务逻辑 */ }
public:
    B(double* _var, A& owner) : pVar(_var) {
        // 绑定私有函数为回调注入到A中
        owner.setVarChangeCb([this](){ onVarChanged(); });
    }
};

优缺点：完全不破坏类封装性，A和B的耦合度极低；缺点是需要额外维护回调的生命周期，避免B析构后回调悬空的问题。

方案3：通用可观察属性封装（复用性最高） #

封装通用的Observable<T>模板类，重载赋值运算符，值变更时自动触发所有注册的回调，无需每个业务类手动写setter触发逻辑。

#include <functional>
template<typename T>
class Observable {
private:
    T val;
    std::function<void(const T&)> onChange;
public:
    Observable(T init = T()) : val(std::move(init)) {}
    void setOnChange(std::function<void(const T&)> cb) { onChange = std::move(cb); }
    Observable& operator=(const T& newVal) {
        if (val != newVal) {
            val = newVal;
            if (onChange) onChange(val);
        }
        return *this;
    }
    // 兼容普通值的读取逻辑
    operator const T&() const { return val; }
};

class A {
public:
    Observable<double> var;
};

class B {
private:
    const Observable<double>* pVar;
    void onVarChanged(const double& newVal) { /* 原有业务逻辑 */ }
public:
    B(const Observable<double>* _var) : pVar(_var) {
        pVar->setOnChange([this](const double& val){ onVarChanged(val); });
    }
};

优缺点：一次封装全场景复用，不需要修改A、B的基础业务逻辑，符合开闭原则，也支持多监听者扩展；缺点是需要额外实现Observable模板，简单场景下有少量代码冗余。

方案4：信号槽机制 #

如果项目使用Qt框架，可以直接用Qt原生信号槽：A定义varChanged信号，B的目标函数声明为私有槽函数，两者绑定后，A的var变更时emit信号即可触发B的私有槽，不需要暴露public接口，Qt元对象系统原生支持私有槽的调用。如果不使用Qt，也可以自行实现轻量信号槽组件，原理和回调类似，天然支持多监听者场景。

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