C++11两种默认的捕获模式：按引用捕获和按值捕获。默认按引用捕获模式可能会带来悬空引用的问题，而默认按值捕获模式也没有解决这个问题，还会让你以为你的闭包是独立的（事实上也不是独立的）。
按引用捕获会导致闭包中包含了对某个局部变量或者形参的引用，变量或形参只在定义lambda的作用域中可用。如果该lambda创建的闭包生命周期超过了局部变量或者形参的生命周期，那么闭包中的引用将会变成悬空引用。
举个例子，假如过滤函数(filtering function)的一个容器，该函数接受一个int，并返回一个bool，该bool的结果表示传入的值是否满足过滤条件：
using FilterContainer = std::vector<std::function<bool(int)>>;
//“using”参见条款9， //std::function参见条款2
FilterContainer filters; //过滤函数我们可以添加一个过滤器，用来过滤掉5的倍数：
filters.emplace_back( //emplace_back的信息见条款42
[](int value) { return value % 5 == 0; }
);可能需要的是能够在运行期计算除数(divisor)，不能将5硬编码到lambda中。
因此添加的过滤器逻辑将会是如下这样：
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的函数添加完，该函数就死亡了。使用这个过滤器（那个添加进filters的函数）会导致未定义行为，这是由它被创建那一刻起就决定了的。
立即使用的闭包按引用捕获是安全的，但是这种安全是不确定的。
当一个lambda表达式被立即使用（例如作为STL算法的参数）且不会被拷贝或存储时，默认按引用捕获模式（[&]）是安全的。这是因为此时闭包的生命周期与父函数局部变量的生命周期一致，不存在悬空引用的风险。
当谈论“立即使用的闭包”时，指的是lambda表达式在其创建后马上被使用，并且不会在函数之外保留或存储。这种情况下，默认按引用捕获模式（[&]）是安全的，因为此时lambda表达式的生命周期与父函数中局部变量的生命周期是一致的。在lambda表达式执行期间，所依赖的所有局部变量都仍然有效。
具体的例子
假设有一个容器，想要检查容器中的所有元素是否都是某个特定除数的倍数。可以使用std::all_of算法和一个lambda表达式来完成这个任务。在这个场景中，lambda表达式将作为std::all_of的一个参数立即被调用，并且不会被保存下来以供以后使用。
// 假设这些函数已经定义好了
int computeSomeValue1(){return 2;}
int computeSomeValue2(){return 3;}
int computeDivisor(int a, int b){return a + b;}
template<typename C>
void checkAllElementsAreMultiples(const C& container) {
auto calc1 = computeSomeValue1();
auto calc2 = computeSomeValue2();
auto divisor = computeDivisor(calc1, calc2);
//立即使用的闭包
if(std::all_of(container.begin(), container.end(),
[&](const typename C::value_type& value)->bool
{
return value % divisor == 0;
})){
std::cout << "All elements are multiples of the divisor.\n";
}
else
{
std::cout << "Not all elements are multiples of the divisor.\n";
}
}
int main() {
std::vector<int> numbers = {5,10,15,20};
checkAllElementsAreMultiples(numbers);
}calc1、calc2 和 divisor 是在 checkAllElementsAreMultiples 函数内部定义的局部变量。lambda表达式：使用默认按引用捕获模式[&]的lambda表达式，它可以访问并修改checkAllElementsAreMultiples 函数内的局部变量。该lambda表达式作为 std::all_of 算法的第三个参数传递，std::all_of 会立即遍历容器并对每个元素应用lambda表达式。一旦 std::all_of 完成，lambda表达式就不再存在。由于lambda表达式是在 checkAllElementsAreMultiples 函数内创建并立即使用，它的生命周期完全包含在该函数的作用域内。因此，lambda表达式访问的局部变量在整个操作期间都是有效的，不存在悬空引用的风险。
C++14支持了在lambda中使用auto来声明变量，上面的代码在C++14中可以进一步简化，ContElemT的别名可以去掉，if条件可以修改为：
if (std::all_of(begin(container), end(container),
[&](const auto& value) // C++14
{ return value % divisor == 0; }))这种做法的安全性是不确定的。如果后续开发中有人将这个lambda表达式复制到其他上下文中使用(比如添加到filters容器中)，而此时divisor等局部变量已经超出作用域，就会重新引入悬空引用的问题。
显式捕获的重要性
显式列出lambda依赖的所有局部变量和形参（如使用[=]或明确指定变量名）是一种更加符合软件工程规范的做法。
（1）显式捕获的重要性在于有助于提高代码可读性。
通过明确指出lambda表达式依赖的外部变量，可以更清晰地传达开发者意图，并且帮助其他阅读代码的人更好地理解代码的行为和潜在的风险。当使用显式捕获时，可以清楚地看到哪些变量被lambda表达式所依赖,使得代码更加直观，读者无需查看整个函数或作用域来确定lambda可能访问哪些变量。如果出现问题，例如某个变量在lambda中未定义或行为不符合预期，显式捕获可以帮助快速定位问题所在。你只需检查lambda的捕获列表即可知道它依赖哪些变量。
（2）预防悬空引用
通过显式列出需要捕获的变量，可以提醒开发者考虑这些变量的生命周期。比如，如果一个变量是在lambda创建后很快就会销毁的局部变量，那么按值捕获可能是更好的选择，以确保lambda内部持有该变量的一个独立副本。
默认按引用捕获模式 [&] 会捕获所有父作用域中的变量，可能导致一些隐藏的依赖关系，增加了代码复杂度和出错几率。显式捕获则强制开发者思考并声明每个依赖项，减少不必要的依赖。对于团队协作开发而言，显式捕获能确保每个成员对代码的理解一致，降低因不同理解而导致的错误风险。
一个解决问题的方法是，divisor默认按值捕获进去，可以按照以下方式来添加lambda到filters。
filters.emplace_back(
[=](int value) { return value % divisor == 0; }
);
//现在divisor不会悬空了在通常情况下，按值捕获并不能完全解决悬空引用的问题。如果按值捕获的是一个指针，将该指针拷贝到lambda对应的闭包里，但这样并不能避免lambda外delete这个指针的行为，从而导致副本指针变成悬空指针。
当按值捕获一个指针变量时，实际上是复制了这个指针的值(内存地址)，不是它所指向的对象。因此，如果原始对象在lambda表达式之外被销毁或删除，那么即使你有一个指针的副本，它也指向了一个已经无效的内存位置。这种情况下的指针被称为悬空指针，使用它会导致未定义行为。
void addPointerFilter() {
int* ptr = new int(10);//动态分配的整数
//按值捕获指针
filters.emplace_back(
[ptr](int value) { return value == *ptr; }
);
delete ptr; //销毁指针指向的对象
}ptr指向的内存是在addPointerFilter函数内部动态分配的。按值捕获了ptr，意味着闭包内有一个指向相同内存位置的指针副本。然而，在delete ptr;之后，该内存位置不再有效，所以闭包内的指针变成了悬空指针。
使用智能指针解决按值捕获指针的问题
使用如std::shared_ptr或std::unique_ptr等智能指针来管理对象的生命周期。智能指针可以通过引用计数等方式自动处理对象的释放，确保只要还有引用存在，对象就不会被销毁。
void addSmartPointerFilter() {
auto ptr = std::make_shared<int>(10);// 使用智能指针
//捕获智能指针
filters.emplace_back(
[ptr](int value) { return value == *ptr; }
);
//不需要手动delete，智能指针会自动管理内存
}假设在一个Widget类，可以实现向过滤器的容器添加条目：
class Widget {
public:
// 构造函数
void addFilter() const; // 向filters添加条目private:
int divisor; // 在Widget的过滤器使用
};这是Widget::addFilter的定义：
void Widget::addFilter()const{
filters.emplace_back(
[=](int value) { return value % divisor == 0; }
);
}这个做法看起来是安全的代码。lambda依赖于divisor，但默认的按值捕获确保divisor被拷贝进了lambda对应的所有闭包中。
但是捕获只能应用于lambda被创建时所在作用域里的non-static局部变量（包括形参）。在Widget::addFilter的视线里，divisor并不是一个局部变量，而是Widget类的一个成员变量。它不能被捕获。而如果默认捕获模式被删除，代码就不能编译了：
voidWidget::addFilter()const{
filters.emplace_back( //错误！
[](int value) { return value % divisor == 0; } //divisor不可用
);
}另外，如果尝试去显式地捕获divisor变量（或者按引用或者按值——这不重要），也一样会编译失败，因为divisor不是一个局部变量或者形参。
voidWidget::addFilter() const{
filters.emplace_back(
[divisor](int value) //错误.没有名为divisor局部变量可捕获
{ return value % divisor == 0; }
);
}如果默认按值捕获不能捕获divisor，而不用默认按值捕获代码就不能编译。解释就是这里隐式使用了一个原始指针:this。每一个non-static成员函数都有一个this指针，每次使用一个类内的数据成员时都会使用到这个指针。例如，在任何Widget成员函数中，编译器会在内部将divisor替换成this->divisor。在默认按值捕获的Widget::addFilter版本中，
voidWidget::addFilter()const{
filters.emplace_back(
[=](int value) { return value % divisor == 0; }
);
}真正被捕获的是Widget的this指针，而不是divisor。编译器会将上面的代码看成以下的写法：
void Widget::addFilter()const{
auto currentObjectPtr = this;
filters.emplace_back(
[currentObjectPtr](int value)
{ return value % currentObjectPtr->divisor == 0; }
);
}明白了这个就相当于明白了lambda闭包的生命周期与Widget对象的关系，闭包内含有Widget的this指针的拷贝。
特别是考虑以下的代码，参考第4章的内容，只使用智能指针：
using FilterContainer = std::vector<std::function<bool(int)>>;
//跟之前一样
FilterContainer filters; //跟之前一样
void doSomeWork(){
auto pw = std::make_unique<Widget>();
//创建Widget；
pw->addFilter(); //添加使用Widget::divisor的过滤器
}
//销毁Widget；filters现在持有悬空指针！当调用doSomeWork时，就会创建一个过滤器，其生命周期依赖于由std::make_unique产生的Widget对象，即一个含有指向Widget的指针——Widget的this指针——的过滤器。这个过滤器被添加到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 Widget::addFilter() const{
auto divisorCopy = divisor; //拷贝数据成员
filters.emplace_back(
[=](int value) //捕获副本
{ return value % divisorCopy == 0; }//使用副本
);
}C++14中,一个更好的捕获成员变量的方式时使用通用的lambda捕获：
void Widget::addFilter() const{
filters.emplace_back( //C++14：
[divisor = divisor](int value) //拷贝divisor到闭包
{ return value % divisor == 0; } //使用这个副本
);
}这种通用的lambda捕获并没有默认的捕获模式，因此在C++14中，本条款的建议——避免使用默认捕获模式——仍然是成立的。
使用C++14通用lambda捕获
void Widget::addFilter() const {
filters.emplace_back(
[divisor = divisor](int value) { // C++14通用捕获，直接拷贝成员变量
return value % divisor == 0;
}
);
}C++14引入通用初始化捕获，使得lambda表达式的捕获列表更加灵活。通过通用初始化捕获，你可以在捕获列表中直接初始化变量，并且这些变量可以是任意类型，包括临时对象、成员变量的副本等。这一特性允许开发者在lambda表达式内部创建并使用局部变量，而无需依赖外部作用域中的变量。
通用初始化捕获的基本形式
[ capture-list ] ( parameters ) mutable -> return-type {
// lambda body
}其中，capture-list 可以包含形如 [identifier = expression] 的元素，用于初始化捕获的变量。这里 identifier 是一个新定义的名字，expression 是用来初始化它的表达式。
静态变量按值捕获可能存在的问题
代码中的关键点是使用了[=]作为捕获列表，这表示lambda会以值的形式捕获外部作用域的所有变量。然而，divisor、calc1 和 calc2 都是静态变量，它们具有静态存储持续时间，意味着它们的生命周期与程序相同，并且不受lambda捕获规则的影响。尽管lambda看起来像是按值捕获了所有东西，实际上它并没有捕获这些静态变量；相反，它直接引用了这些静态变量。
由于divisor是一个静态变量，它在每次调用addDivisorFilter时都会递增。这意味着每一个新创建的lambda都将使用更新后的divisor值，而不是创建时的值。因为读者可能误以为每个lambda都是独立的，并且保存了创建时的环境状态。
为了消除这种风险，可以明确地指定要捕获的变量，而不是依赖默认的捕获模式。如果确实需要使用静态变量，应该清楚地表明这一点，并确保理解其行为。
void addDivisorFilter() {
static auto calc1 = computeSomeValue1(); // 静态计算值1
static auto calc2 = computeSomeValue2(); // 静态计算值2
static auto divisor = computeDivisor(calc1, calc2); // 静态除数
// 明确指出我们不捕获任何局部变量
filters.emplace_back(
[] (int value) -> bool {
return value % divisor == 0; // 直接使用静态变量divisor
}
);
++divisor; // 调整静态除数
}如果希望每个lambda都拥有自己的一份divisor副本，应该在divisor更新之前就对其进行捕获。
void addDivisorFilter() {
static auto calc1 = computeSomeValue1();
static auto calc2 = computeSomeValue2();
static auto divisor = computeDivisor(calc1, calc2);
//在divisor更新前进行捕获
auto current_divisor = divisor;
filters.emplace_back(
[current_divisor](int value) -> bool {
return value % current_divisor == 0; // 使用当前的divisor值
}
);
++divisor;
}这样可以确保每个lambda都有自己的divisor值副本，并且不会受到后续对静态变量divisor修改的影响。
