在构造函数中创建Lambda引发的问题及解决方法咨询

你的代码核心问题在于：Object构造函数里的Lambda捕获了裸指针this，当Object被移动到ObjectReceiver的object成员时，原临时Object被销毁，但Lambda内的this依然指向那个已失效的内存地址。调用callback时，修改的是无效内存中的变量，而非移动后新对象的variable，所以最终输出还是初始值10。

下面是几种实用的解决方案，你可以根据场景选择：

方案1：禁用移动操作（简单直接） #

如果你的类不需要支持移动语义，直接显式禁用移动构造和移动赋值，从根源阻止可能的错误：

class Object {
public:
    int variable = 10;
    std::function<void()> callback;

    Object() {
        callback = [this]() {
            variable += 10;
        };
    }

    // 禁用移动构造
    Object(Object&&) = delete;
    // 禁用移动赋值
    Object& operator=(Object&&) = delete;
};

此时ObjectReceiver receiver{Object()};会直接编译报错，避免后续隐藏bug。

方案2：实现正确的移动构造/赋值，更新Lambda绑定 #

如果必须支持移动语义，需要在移动过程中重新初始化回调，让Lambda捕获新对象的this：

class Object {
public:
    int variable = 10;
    std::function<void()> callback;

    Object() {
        setupCallback();
    }

    // 移动构造函数
    Object(Object&& other) noexcept 
        : variable(std::move(other.variable)) {
        setupCallback();
        // 置空原对象的回调，防止其访问已失效内存
        other.callback = nullptr;
    }

    // 移动赋值运算符
    Object& operator=(Object&& other) noexcept {
        if (this != &other) {
            variable = std::move(other.variable);
            setupCallback();
            other.callback = nullptr;
        }
        return *this;
    }

private:
    // 提取回调初始化逻辑，避免重复代码
    void setupCallback() {
        callback = [this]() {
            variable += 10;
        };
    }
};

移动完成后，新对象的callback会绑定自身的this，调用后会正确修改variable，输出变为20。

方案3：延迟回调初始化，避免构造时绑定 #

约定不在构造函数中创建绑定this的Lambda，改用成员函数手动初始化回调，确保对象生命周期稳定后再绑定：

class Object {
public:
    int variable = 10;
    std::function<void()> callback;

    Object() = default;

    // 手动初始化回调的成员函数
    void initCallback() {
        callback = [this]() {
            variable += 10;
        };
    }
};

// 使用示例
int main() {
    ObjectReceiver receiver{Object()};
    receiver.object.initCallback(); // 移动完成后再初始化回调
    receiver.object.callback();
    std::cout << receiver.object.variable << std::endl; // 输出20
    return 0;
}

这种方式把回调初始化的时机交给使用者，从流程上避免移动导致的指针失效。

方案4：用std::enable_shared_from_this捕获智能指针（适合共享所有权场景） #

如果对象由std::shared_ptr管理，让Lambda捕获shared_ptr而非裸指针this，即使对象所有权转移，Lambda依然持有有效的对象引用：

#include <memory>

class Object : public std::enable_shared_from_this<Object> {
public:
    int variable = 10;
    std::function<void()> callback;

    // 构造函数中不能直接调用shared_from_this，需配合工厂函数
    static std::shared_ptr<Object> create() {
        auto ptr = std::shared_ptr<Object>(new Object());
        ptr->setupCallback();
        return ptr;
    }

private:
    Object() = default;

    void setupCallback() {
        auto self = shared_from_this();
        callback = [self]() {
            self->variable += 10;
        };
    }
};

class ObjectReceiver {
public:
    std::shared_ptr<Object> object;

    explicit ObjectReceiver(std::shared_ptr<Object> obj) : object(std::move(obj)) {}
};

int main() {
    auto receiver = ObjectReceiver{Object::create()};
    receiver.object->callback();
    std::cout << receiver.object->variable << std::endl; // 输出20
    return 0;
}

该方案适合对象需要被多个组件共享的场景，彻底避免裸指针失效问题。

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