Item31 Avoid default capture modes

   C++11中Lambda表达式给C++带来了很大的改变,通过Lambda可以很方便的创建一个函数对象,这对于C++的开发来说影响是巨大的,比如可以很方便的结合STL的一些算法,不用再单独创建函数来用,还有可以很好的结合std::unique_ptrstd::shared_ptr,帮助其创建定制删除器等。从字面意义上来看难免让人疑惑Lambda到底是什么,下面则是对Lambda的一个浅显易懂的解释。

  • 一个Lambda表达式仅仅是一个表达式,它是源代码的一部分
std::find_if(container.begin(), container.end(), [](int val) { return 0 < val && val < 10; });
  • 闭包是一个由Lambda表达式创建的运行时对象,根据Lambda的捕获模式的不同,闭包会拷贝或者引用捕获的数据, 在上面的代码中闭包作为一个运行时对象传递给了std::find_if
  • 闭包类是一个类,闭包则是它实例化的结果,每一个lambda都会导致编译器生成唯一的闭包类,然后将执行语句放到闭包类的成员函数中。

   一个Lambda通常用于创建一个闭包,然后作为函数的参数进行传递,例如上文中的std::find_if,但有的时候会进行拷贝,也就是说对一个Lambda阐述的闭包类型存在多个闭包实例,例如下面这段代码。

int x;
auto c1 = [x](int y) { return x * y > 55; }
auto c2 = c1;
auto c3 = c2

上面代码中的 c1,c2,c3都是同一个lambda表达式产生的闭包类型的实例。

​   总结一下,Lambda,闭包类,闭包,这是三个不同的概念,前两者之存在于编译期,后者是一个运行时的概念,是闭包类的实例化的结果。

   说完了Lambda本身,接下来就要进入本文的重点,Lambda捕获,在C++11中有两种捕获模式一种是引用,另外一种则是值,默认的引用传递可能会导致引用悬挂的问题,因为引用的变量其生命周期和闭包本身的生命周期不一致,如果引用的变量其生命周期短于闭包的生命周期,那么就会导致引用悬挂的问题。例如下面这个例子:

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

void addDivisorFilter() {
    .......
    auto divisor = computeDivisor();
    filters.emplace_back(
        [](int value) { return value % divisor == 0; };
    )
}

   上面的代码中,filters存放了闭包,闭包中引用了局部变量divisor,当离开作用域的时候divisor析构,此时若要使用filters里面存放的闭包则会导致程序遇到引用悬挂的问题。一眼看上去很难去发现这个问题,需要在lambda的实现中去找引用了哪些外部的变量,加剧了发现问题的难度,通过显示的引用可以解决这个问题。

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

上门的代码显示的引用了外部变量divisor,那么使用者就可以根据这个显示的声明去发现存在的问题。

   总结来说这种引用捕获的模式,需要时刻注意引用的变量其生命周期应该要长于闭包的生命周期,只有在这种场景下才比较适合使用引用捕获的这种模式。

​对于闭包生命周期比较长的场景可以使用值拷贝这种模式,如下:

filters.emplace.back( 
 [=](int value) { return value % divisor == 0; }
)

   但是这种方式也存在一些问题,比如对于指针的拷贝,尽管可以将指针拷贝到闭包中,但是阻止不了外部指针被delete导致悬挂指针的问题,例如下面这个例子:

class Widget {
  public:
    void addFilter() const;
  private:
    int divisor;
}

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

   上面的代码通过默认的值拷贝方式将divisor拷贝到闭包中,看起来上面的闭包很安全。实际上这种说法是错误的。首先来看下面这段代码:

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

   上面是显示的将divisor值拷贝到闭包中,但是编译出错了,因为对于lambda来说只能捕获在可见作用域内的非静态的局部变量,而divisor是一个成员变量。也就是说值拷贝divisor的这种方式行不通,但是上面的默认值拷贝方式却可以编译通过,这都是编译器帮我做了一些事让我们误认为是divisor值拷贝进去的,下面是还原后的代码:

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

​   真相就是this指针了,其实拷贝是this指针,对divisor的引用是通过this指针进行的。既然知道了真相,那么这种方式安全吗? 坦白说同样不安全,因为this指针会失效,存在悬挂指针的风险,例如下面的这段代码:

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

void doSomeWork() {
  auto pw = std::make_unique<Widget>();
  pw->addFilter();
}

   上面的代码中pw在执行完addFilter就析构了,这导致闭包中拷贝的this指针失效了。这个问题可以通过下面这种方法来解决。

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

   这不失为一种不错的方法,更幸运的是在C++14中,将上面这种方式直接内置支持了,上面的代码在C++14中可以像下面这样来写。

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

   值拷贝也好,引用也好,这些都只是针对非静态的局部变量,对于静态的,或者是全局变量,那么lambda的捕获将不会起任何作用,和值拷贝不一样的是,lambda不会将静态的或者是全局变量包含到闭包类中,因为这些变量在外部改变后,会影响lambda的行为,而值拷贝不一样,它拷贝的是某一时刻变量的值,此后这个值就被包含到lambda中并且不会因为外部变量的改变而改变。例如下面这个例子:

    static int static_test = 100;
    auto pw = [=](){
        std::cout << static_test << std::endl;
    };
    ++static_test;
    pw();

   上面的代码使用了默认的值拷贝方式,这让人产生了错觉,觉得static_test是通过值拷贝的方式传入的,其实并不是,通过上文的介绍,我们知道对于静态变量是不会捕获的。因此static_test是直接引用外部的,所以起行为收到外部static_test的影响。pw()的运行结果是101

©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值