CERT C++: EXP61-CPP

The issue occurs when a lambda expression captures an object by reference and the lambda expression object outlives the captured object. For instance, the captured object is a local variable but the lambda expression object has a much larger scope.

If a lambda expression object outlives one of its reference captured objects, the captured object can be accessed outside its scope.

For instance, consider this function createFunction:

std::function<std::int32_t()> createFunction() {
   std::int32_t localVar = 0;
   return ([&localVar]() -> std::int32_t {
       localVar = 1;
       return localVar;
   });
}

createFunction returns a lambda expression object that captures the local variable localVar by reference. The scope of localVar is limited to createFunction but the lambda expression object returned has a much larger scope.

This situation can result in an attempt to access the local object localVar outside its scope. For instance, when you call createFunction and assign the returned lambda expression object to another object aFunction:

auto aFunction = createFunction();

std::int32_t someValue = aFunction();

If a function returns a lambda expression, to avoid accessing a captured object outside its scope, make sure that the lambda expression captures all objects by copy. For instance, you can rewrite createFunction as:

std::function<std::int32_t()> createFunction() {
   std::int32_t localVar = 0;
   return ([localVar]() mutable -> std::int32_t {
       localVar = 1;
       return localVar;
   });
}

auto createAdder(int amountToAdd) {
  int addThis = amountToAdd; //Noncompliant
  auto adder = [&] (int initialAmount) {
      return (initialAmount + addThis);
  };
  return adder;
}
 
void func() {
  auto AddByTwo = createAdder(2);
  int res = AddByTwo(10);
}

In this example, the createAdder function defines a lambda expression adder that captures the local variable addThis by reference. The scope of addThis is limited to the createAdder function. When the object returned by createAdder is called, a reference to the variable addThis is accessed outside its scope. When accessed in this way, the value of addThis is undefined.

If a function returns a lambda expression object, avoid capturing local variables by reference in the lambda object. Capture the variables by copy instead.

auto createAdder(int amountToAdd) {
  int addThis = amountToAdd;
  auto adder = [=] (int initialAmount) {
      return (initialAmount + addThis);
  };
  return adder;
}
 
void func() {
  auto AddByTwo = createAdder(2);
  int res = AddByTwo(10);
}