0

我有一个类成员，它的类型通过使用std::function绑定到this指针std::bind。

我实现了赋值运算符，它还必须复制可调用对象，但是问题在于，this应该复制哪个？这个this还是其他this？

这是用于演示的示例可编译代码：

#include <functional>
#include <iostream>

using func = std::function<void()>;

struct A
{
    ~A()
    {
        std::cout << "---destructor: " << this << std::endl;
        other_callable();
        this_callable();
    }

    A(const char* name) :
        mName(name)
    {
        other_callable = std::bind(&A::f, this);
        this_callable = std::bind(&A::f, this);
    }

    A& operator=(const A& ref)
    {
        if (this != &ref)
        {
            other_callable = ref.other_callable;
            this_callable = std::bind(&A::f, this);

            mName = ref.mName;
        }

        return *this;
    }

    void f()
    {
        std::cout << mName << ": " << this << std::endl;
    }

    func other_callable;
    func this_callable;
    const char* mName;
};

int main()
{
    A a("a");
    A b("b");

    a.other_callable();
    b.this_callable();
    std::cout << "-------------------" << std::endl;

    a = b;
}

以下是非唯一示例输出：

a: 00000090447FF3E0
b: 00000090447FF490
-------------------
---destructor: 00000090447FF490
b: 00000090447FF490
b: 00000090447FF490
---destructor: 00000090447FF3E0
b: 00000090447FF490
b: 00000090447FF3E0

如您所见，在第二个实例中调用了非预期的可调用对象。

问题是什么？

问题在于this存储在可调用对象内的指针，复制可调用对象也会复制this指针，这意味着this不再this是“其他”。

为了理解我的问题，可调用对象是从外部代码调用的事件回调，它假定可调用将在this实例上执行但它不会，它在复制的其他实例上执行。

我的问题是在这里实现复制语义的正确方法是什么？现在我更喜欢这个this_callable版本，而不是other_callable因为它指的是 thisthis而不是 other this。

但是我不确定这是好是坏，超出了它的预期效果，而简单地复制可调用（other_callable）会导致我的代码中的错误在这个例子之外不容易解释。

我的设计是否this_callable可以接受，还是应该other_callable用于复制语义并在其他地方更改设计？

4

0 回答 0