知道何时指向对象更改

Question

在 C++ 中有没有一种方法，使用原始指针或其他方式在指向对象发生变化时触发某些操作？

场景：

class A
{
    double var;
    B var2 {&var};
}

class B
{
   double* pVar;
   B (double* _var ) { pVar = _var};
}

我在 B 类中有函数，只要成员变量 var 更改值，就会调用这些函数。目前我需要将这些函数公开，以便可以从 A 类手动调用它们，这可以通过使用 var 的 setter 来实现。如果我想让 B 类中的函数保持私有（因为它被 B 类内部的其他事件调用），我有什么选择？

Answer 1

这是观察者模式的一个例子。 所以你需要的是触发对另一个对象的函数调用 当您的对象的值通过 setter 方法更改时。

#include <functional>
#include <iostream>

//-----------------------------------------------------------------------------
// the class with the member variable that can change
// and to which another class can react.
// This is a simple example where only one "callback" function
// can be registered. In the typical observer pattern
// there can be multiple callbacks registered.

class Observee
{
public:

    // set notification function to a function that does nothing
    // "null strategy pattern"
    Observee() :
        m_notify_observer_fn{ [](int) {} }
    {
    }

    // let another object pass in a function that will be called
    // when the value is changed
    void OnValueChanged(std::function<void(int)> notify_observer_fn)
    {
        m_notify_observer_fn = notify_observer_fn;
    }

    // to change the member value AND notify the other object
    // that the value has changed we need a setter function.
    void set_value(int value)
    {
        // check if the value really has changed
        if (m_value != value)
        {
            // set the member value
            m_value = value;

            // then notify the observer of the new value
            // by calling the notification function
            m_notify_observer_fn(m_value);
        }
    }

private:
    std::function<void(int)> m_notify_observer_fn;
    int m_value{};
};

//-----------------------------------------------------------------------------
// The class that wants to get a notification when the value
// of the other class changes (role is an Observer)

class Observer
{
public:
    explicit Observer(Observee& observee)
    {
        // Set the callback in the observee to the OnValueChanged
        // function of this object (the function passed is called a lambda funtion)
        observee.OnValueChanged([this](int value)
        {
            OnValueChanged(value);
        });
    }

private:
    void OnValueChanged(int value)
    {
        std::cout << "Value changed to " << value << "\n";
    }
};

//-----------------------------------------------------------------------------

int main()
{
    // make instances of both classes.
    Observee observee;
    Observer observer{ observee };

    // now set the value
    // this will change the member in observee
    // and then call the method in the observer for you
    observee.set_value(42);

    return 0;
}

Answer 2

问题：如果我想让 B 类中的函数保持私有（因为它被 B 类内部的其他事件调用），我有什么选择？

您可以在使用朋友属性对A类进行编码时调用B类的私有函数。

class B 
{
    friend class A;
private:
    void foo() { std::cout << "using foo." << std::endl; }
};

class A
{
private:
    B b;
public:
    void bar(){ b.foo(); }
};

int main()
{
    A a;
    a.bar();
    return 0;
}

关于双变量更改其值时要调用的回调： 不，你不能用原始指针来做。

您至少有两种方法。 第一种方法是您概述的：使用 setter 函数。 第二个是创建一个拥有该值并且重载 operator= 能够调用回调的类。 我会在这里画一些草图让你更好地理解：

template<class T>
class Owner{
    using FuncType = std::function<void(Owner<T>&)>;
    
public:
    Owner(){}
    Owner(const T& init){
        _var = init;
    }
    Owner(const Owner<T>& init){
        _var = init;
    }
    operator T(){
        return _var;
    }
    auto& operator =(const T& rvalue){
        _var = rvalue;
        _on_change();
        return *this;
    }
    auto& operator =(const Owner<T>& rvalue){
        _var = rvalue;
        _on_change();
        return *this;
    }
    const T& get() const { //don't make it non const or
                           //you will lose ownership to value of _var
        return _var;
    }
    void set(const T& val){
        _var = val;
        _on_change();
    }
    void set(const Owner<T>& val){
        _var = val;
        _on_change();
    }
    
    void set_handler(FuncType func)
    {
        _func = func;
    }
    
    
private:
    void _on_change(){
        if(_func)
            _func(*this);
    }
    
private:
    T _var{};
    FuncType _func{};
};



int main()
{
    Owner<double> var{};
    var.set_handler([](Owner<double>& ch){
        std::cout << "Value changed: " << (double) ch << std::endl;    
    });
    
    var = 1.0;
    return 0;
}