Clause 31: avoid default capture mode

C++11 There are two default capture methods in ： By value or by reference . The default capture by value may fool you , Default capture by reference may result in dangling references .

Capturing by reference causes closures to contain references to local variables , Or it comes to definitions lambda A reference to a formal parameter within the scope of a formula , Consider the following code ：

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(					//  dangerous , Yes divisor The reference of may be suspended ！
    	[&](int value){
     return value % divisor == 0;}
    );
}

The above code can go wrong at any time ,lambda Formula refers to local variables diviisor References to , But this variable is in addDivisorFilter It does not exist on return . Even if not , Instead, capture by reference in a display way divisor, The problem remains.

filters.emplace_back(					//  dangerous , Yes divisor The reference of may be suspended ！
    [&divisor](int value){
     return value % divisor == 0;}

One way to solve this problem is to use capture by value ：

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

Enough for this example ; But the problem is ： After capturing by value A pointer after , stay lambda The closure created by the formula holds a copy of the pointer , But you can't stop lambda Code other than implements... For this pointer delete Null pointer copy caused by operation ;

Consider the following code ：

class widget {
    
public:
    void addFilter() const;

private:
    int divisor;
};

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

Capture can only be made for when creating lambda Non static local variables visible to the scope of an expression （ Including formal parameters ）. stay wdiget::addFilter In the function body of ,divisor Not a local variable , It is widget Member variables of class . It can't catch at all . In this way , If the default capture mode is eliminated , Code can't be Compile ：

void widget::addFilter() const
{
    
    filters.emplace_back([](int value){
     return value % divisor == 0;}); //  error ！ There is nothing to capture divisor
}

If you try to display a capture divisor, This capture statement cannot be compiled , because divisor Not a local variable , Nor is it a formal parameter

void widget::addFilter() const
{
    
    filters.emplace_back([divisor](int value){
     return value % divisor == 0;}); //  error ！ There is nothing to capture divisor
}

Consider the following code ：

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

void doSomeWork() {
    
	auto pw = std::make_unique<Widget>();
	pw->addFilter();
	// ... Widget Be destroyed ,filter Now hold the dangling pointer 
}

call doSomeWork Created a filter function , Depend on std::make_unique Created Widget object , The function is to filters in , However, when doSomeWork After execution ,Widget An object is the one that manages its life cycle std::unique_ptr The destruction . From that moment on ,filter Contains an element with a null pointer . This problem can be solved by copying the member variables you want to capture into local variables , Then capture the local variable to solve :

void Widget::addFilter() const {
    
	auto divisorCopy = divisor; //  Copy member variables 
	filter.emplace_back(
		[divsorCopy](int value)	//  Capture copy 
		{
     return value % divisorCopy == 0};	//  Use copy 
	)
}