31-避免使用默认捕获模式

C++

发布日期: 2022-09-18

按引用捕获会导致闭包中包含了对某个局部变量或者形参的引用，变量或形参只在定义lambda的作用域中可用。如果该lambda创建的闭包生命周期超过了局部变量或者形参的生命周期，那么闭包中的引用将会变成悬空引用

假如我们有元素是过滤函数（filtering function）的一个容器，该函数接受一个int，并返回一个bool，该bool的结果表示传入的值是否满足过滤条件

using FilterContainer = std::vector<std::function<bool(int)>>;
FilterContainer filters;                    //过滤函数

可能需要在运行时计算形参是不是某个数的倍数

void addDivisorFilter()
{
    auto calc1 = computeSomeValue1();
    auto calc2 = computeSomeValue2();

    auto divisor = computeDivisor(calc1, calc2);

    filters.emplace_back(                               //危险！对divisor的引用将会悬空！
        [&](int value) { return value % divisor == 0; }
    );
}

lambda对局部变量divisor进行了引用，但该变量的生命周期会在addDivisorFilter返回时结束，刚好就是在语句filters.emplace_back返回之后。因此添加到filters的函数添加完，该函数就死亡了。使用这个过滤器会导致未定义行为

同样的问题也会出现在divisor的显式按引用捕获

filters.emplace_back(
    [&divisor](int value) 			    //危险！对divisor的引用将会悬空！
    { return value % divisor == 0; }
);

但通过显式的捕获，能更容易看到lambda的可行性依赖于变量divisor的生命周期

一个解决问题的方法是，divisor默认按值捕获进去

filters.emplace_back( 							    //现在divisor不会悬空了
    [=](int value) { return value % divisor == 0; }
);

通常情况下，按值捕获并不能完全解决悬空引用的问题。如果按值捕获的是一个指针，将该指针拷贝到lambda对应的闭包里，但这样并不能避免lambda外delete这个指针的行为，从而导致你的副本指针变成悬空指针

假设在一个Widget类，可以实现向过滤器的容器添加条目：

class Widget {
public:
    void addFilter() const; //向filters添加条目
private:
    int divisor;            //在Widget的过滤器使用
};

void Widget::addFilter() const
{
    filters.emplace_back(
        [=](int value) { return value % divisor == 0; }
    );
}

捕获只能应用于lambda被创建时所在作用域里的non-static局部变量（包括形参）。在Widget::addFilter的作用域里，divisor并不是一个局部变量，而是Widget类的一个成员变量。它不能被捕获

显式地捕获divisor变量，也一样会编译失败

void Widget::addFilter() const
{
    filters.emplace_back(
        [divisor](int value)                //错误！没有名为divisor局部变量可捕获
        { return value % divisor == 0; }
    );
}

这里隐式使用了一个原始指针：this。每一个non-static成员函数都有一个this指针，每次你使用一个类内的数据成员时都会使用到这个指针。例如，在任何Widget成员函数中，编译器会在内部将divisor替换成this->divisor。在默认按值捕获的Widget::addFilter版本中真正被捕获的是Widget的this指针，而不是divisor，编译器会将上面的代码看成以下的写法

void Widget::addFilter() const
{
    auto currentObjectPtr = this;

    filters.emplace_back(
        [currentObjectPtr](int value)
        { return value % currentObjectPtr->divisor == 0; }
    );
}

所以现在的lambda就跟对象的声明周期有关了，如果对象被销毁了，那捕获到的指针就变成悬空指针了

using FilterContainer = std::vector<std::function<bool(int)>>;

FilterContainer filters;

void doSomeWork()
{
    auto pw = std::make_unique<Widget>();
    
    pw->addFilter();                        //添加使用Widget::divisor的过滤器
}                                           //销毁Widget；filters现在持有悬空指针！

当调用doSomeWork时，就会创建一个过滤器，其生命周期依赖于由std::make_unique产生的Widget对象，即一个含有指向Widget的指针的过滤器。这个过滤器被添加到filters中，但当doSomeWork结束时，Widget会由管理它的std::unique_ptr来销毁。从这时起，filter会含有一个存着悬空指针的条目

同样可以用按值捕获来解决

void Widget::addFilter() const
{
    auto divisorCopy = divisor;                 //拷贝数据成员

    filters.emplace_back(
        [divisorCopy](int value)                //捕获副本
        { return value % divisorCopy == 0; }	//使用副本
    );
}

如果按值“捕获”局部静态变量

void addDivisorFilter()
{
    static auto calc1 = computeSomeValue1();    //现在是static
    static auto calc2 = computeSomeValue2();    //现在是static
    static auto divisor =                       //现在是static
    computeDivisor(calc1, calc2);

    filters.emplace_back(
        [=](int value)                          //什么也没捕获到！
        { return value % divisor == 0; }        //引用上面的static
    );

    ++divisor;                                  //调整divisor
}

lambda的代码引用了static变量divisor，在每次调用addDivisorFilter的结尾，divisor都会递增，通过这个函数添加到filters的所有lambda都展示新的行为。这个lambda是通过引用捕获divisor，这和默认的按值捕获表示的含义有着直接的矛盾

请记住：