掌握C++回调：按值捕获、按引用捕获与弱引用

2024-07-23 18:36:01 浏览数 (1)

在C 回调中，当使用Lambda表达式捕获外部变量时，有两种捕获方式：按值捕获和按引用捕获。

一、按引用捕获和按值捕获

1.1 原理

  • 按引用捕获是将外部变量的引用存储在Lambda表达式的闭包中，[&] 表示按引用捕获所有外部变量。这样，当Lambda表达式执行时，它将直接访问原始变量。这种方式在某些情况下可能导致问题，例如，当回调执行时，原始变量已经失效（例如，原始变量是栈上的局部变量，而回调在该变量离开作用域后执行）。
  • 按值捕获是将外部变量的值复制到Lambda表达式的闭包中。这样，当Lambda表达式执行时，它将使用这个复制的值，而不是原始变量的值。这种方式可以避免在回调执行时，原始变量已经失效的问题。

1.2 案例

原理虽然很简单，但是当我们处于复杂的业务代码中时，仍然不免会写出bug。下面是笔者遇到的一个真实案例：

代码语言：javascript复制
    std::string WebProxyKeysHelper::GetAuthCode(std::string &st_or_code, std::string &last_key) {
     ...
     auto ph = (st_or_code == KEY_TYPE_OF_ST_STR ? RefreshProxySt() : RefreshOauthCode());
        auto prom_ptr = std::make_shared<std::promise<std::string>>();
        std::future<std::string> fut_pb = prom_ptr->get_future();
        ph.then([&, prom_ptr](bool ret) {
         std::string tmp_key = "";
            if (ret) {
                tmp_key = st_or_code == KEY_TYPE_OF_ST_STR ? proxy_st_ : oauth_code_;
                UpdateKeys(st_or_code, tmp_key);
                Schedule();
            }
            prom_ptr->set_value(tmp_key);
        })
        .onError([&, prom_ptr](const std::exception& ex){
            prom_ptr->set_value("");
         });
    }
    ...
    return current_key;
 }

在上述代码中，WebProxyKeysHelper::GetAuthCode 函数通过异步操作 ph 获取代理密钥。然后，根据异步操作的结果，回调函数更新密钥并设置 prom_ptr 的值。然而，这段代码存在一个潜在的问题，即在回调函数中使用了按引用捕获的 st_or_code 变量。

问题在于，当 ph.then([&, prom_ptr](bool ret) { ... }) 回调执行时，st_or_code 变量可能已经离开了作用域并被销毁。这会导致程序偶现闪退，也可能导致数值异常，最终表现为业务逻辑异常，因为回调函数试图访问一个已经失效的栈变量。

修改的方式是，将 st_or_code 变量改为按值捕获。这样，在回调执行时，即使原始的 st_or_code 变量离开了作用域，回调中仍然可以安全地使用其复制的值。下面是修正后的代码：

代码语言：javascript复制
    std::string WebProxyKeysHelper::GetAuthCode(std::string &st_or_code, std::string &last_key) {
        ...
        auto ph = (st_or_code == KEY_TYPE_OF_ST_STR ? RefreshProxySt() : RefreshOauthCode());
        auto prom_ptr = std::make_shared<std::promise<std::string>>();
        std::future<std::string> fut_pb = prom_ptr->get_future();
        ph.then([&, st_or_code, prom_ptr](bool ret) { // 注意这里改为按值捕获 st_or_code
            std::string tmp_key = "";
            if (ret) {
                tmp_key = st_or_code == KEY_TYPE_OF_ST_STR ? proxy_st_ : oauth_code_;
                UpdateKeys(st_or_code, tmp_key);
                Schedule();
            }
            prom_ptr->set_value(tmp_key);
        })
        .onError([&, prom_ptr](const std::exception& ex){
            prom_ptr->set_value("");
        });
    }
    ...
    return current_key;
}

二、弱引用

2.1 原理

弱引用（Weak Reference）是一种特殊的引用类型，它不会阻止其所引用的对象被垃圾回收。这在处理回调和长时间运行的任务时非常有用，因为它可以避免因为回调导致的潜在内存泄漏。

2.2 案例一：使用std的弱引用

我们先看一下错误的写法：

代码语言：javascript复制
class Foo {
public:
    void start() {
        std::thread t([this]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            this->doSomething();  // Undefined behavior if `this` is destroyed!
        });
        t.detach();
    }

    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
};

在上述代码中，我们在新线程中访问了this指针。然而，如果新线程开始执行时，this指针所指向的对象已经被销毁，这将导致未定义的行为。

正确的写法如下：

代码语言：javascript复制
class Foo : public std::enable_shared_from_this<Foo> {
public:
    void start() {
        std::thread t([weak_this = std::weak_ptr<Foo>(shared_from_this())]() {
            if (auto shared_this = weak_this.lock()) {
                shared_this->doSomething();  // 安全，只要 `this` 没有被销毁
            }
        });
        t.detach();
    }

    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }
};

在修正的代码中，我们使用了弱引用来捕获this指针。这样，即使原始对象被销毁，新线程中也不会访问到无效的this指针。

2.3 案例二：使用base库的弱引用

base::BindLambda(base::AsWeakPtr(this), [&] { ... }) 使用了弱引用。这里，base::AsWeakPtr(this) 将this指针转换为弱引用，并将其传递给Lambda表达式。这样，在回调执行时，如果this指针所指向的对象已经被销毁，回调将不会执行，从而避免了潜在的内存泄漏问题。

下面是执行CGI任务时的回调写法。当CGI网络请求回来时，所在的Service类可能已经被析构，所以需要使用base::AsWeakPtr(this) 将this指针转换为弱引用：

代码语言：javascript复制
task->SetCallback(base::BindLambda(base::AsWeakPtr(this), [=](network::ProtocolErrorCode pec, const CRTX_WWK::BatchSetLeaderRsp& resp) {
    LogicErrorCode code = (pec == network::PEC_OK && task->response_head()->errcode() == 0) ? LEC_OK : LEC_ERROR;
    if(code == LEC_OK) {
     ...
    }
    if (!callback.is_null()) callback.Run(code);
})); 
ScheduleTask(task.get());

大家可能已经注意到，上面的Lamda回调中，我们不需要再额外判断this是否已经被析构，因为base库已经替我们提前判断好再回调：

代码语言：javascript复制
/**
 * @brief BindLambda 函数实现了便捷的通过 C   Lambda 表达式来创建 base::Callback 的方法。
 * 这个重载允许额外传入一个 base::WeakPtr 类型的弱引用，在实际执行 functor 前会检查弱引用的有效性，如果弱引用已经无效，则不会执行 functor。
 *
 * @param weakptr 额外传递一个弱引用，在 functor 执行前会进行检查，如果该弱引用无效则不会继续调用 functor
 * @param functor C   Lambda 表达式
 * @param params 需要绑定在 Lambda 表达式上的参数
 *
 * @note 可根据实际情况，选择使用捕获或者绑定的方式传递参数。
 */
template <typename SupportWeakPtrType, typename Functor, typename ...Params>
auto BindLambda(const WeakPtr<SupportWeakPtrType>& weakptr, const Functor& functor, const Params&... params) -> decltype(BindLambda(functor, params...)) {
    return _WrapWeakCallback(BindLambda(functor, params...), weakptr);
}

template <typename SupportWeakPtrType, typename RetType, typename ...Params>
base::Callback<RetType(Params...)> _WrapWeakCallback(const base::Callback<RetType(Params...)>& callback, const WeakPtr<SupportWeakPtrType>& weakptr) {
    return base::Bind(&_RunWeakCallbackInternalRet<SupportWeakPtrType, RetType, Params...>, weakptr, callback);
}

template <typename SupportWeakPtrType, typename RetType, typename ...Params>
RetType _RunWeakCallbackInternalRet(const WeakPtr<SupportWeakPtrType>& weakptr, const base::Callback<RetType(Params...)>& callback, Params... params) {
    if (weakptr.get()) {
        return callback.Run(params...);
    }
    return RetType();
}

上面是base库的源码实现，逻辑解释如下：

  1. BindLambda 函数接受一个弱引用（weakptr）、一个Lambda表达式（functor）和一些参数（params）。它将创建一个回调函数，该回调在执行前会检查弱引用的有效性。如果弱引用无效，则不会执行Lambda表达式。
  2. _WrapWeakCallback 函数接受一个回调函数（callback）和一个弱引用（weakptr）。它将创建一个新的回调函数，该回调函数在调用之前会检查弱引用的有效性。
  3. _RunWeakCallbackInternalRet 函数在弱引用有效时执行回调函数（callback），否则返回默认值。这个函数实际上是在执行回调之前检查弱引用的有效性的地方。

三、总结

在C 回调中，我们需要根据具体情况选择合适的捕获方式（按值捕获、按引用捕获或弱引用）。在处理回调和长时间运行的任务时，为了避免内存泄漏和访问无效变量的问题，我们通常需要使用按值捕获和弱引用。

最后我们用表格总结一下本文：

类型

原理

注意事项

按值捕获

将外部变量的值复制到Lambda表达式的闭包中，使得Lambda表达式在执行时使用的是复制的值，而不是原始变量的值。

如果捕获的变量在Lambda表达式执行时已经离开了作用域，那么按值捕获就是安全的，因为Lambda表达式中使用的是变量的副本。

按引用捕获

将外部变量的引用存储在Lambda表达式的闭包中，使得Lambda表达式在执行时直接访问的是原始变量。

如果捕获的变量在Lambda表达式执行时已经离开了作用域，那么按引用捕获就可能导致未定义的行为。因此，使用按引用捕获时，需要确保捕获的变量在Lambda表达式执行时仍然有效。

弱引用

弱引用是一种特殊的引用类型，它不会阻止其所引用的对象被垃圾回收。这在处理回调和长时间运行的任务时非常有用，因为它可以避免因为回调导致的潜在内存泄漏。

如果弱引用所引用的对象在回调执行时已经被销毁，那么回调将不会执行，从而避免了潜在的内存泄漏问题。因此，使用弱引用时，需要确保在回调执行时，弱引用所引用的对象仍然存在。

c++ 变量 对象 函数 指针

0 人点赞