Are my lambda parameters really shadowing my locals?

Question

I\'m dealing with some C code that takes some data, and forwards it to the function passed in:

void foo(int* data, void (*fun)(int*)){
  (*fun)(data);
};
<         


        

Answer 1

In reference to MISRA C++ 2008: An identifier declared in an inner scope should never have the same name as an identifier declared in the outer scope.

In your example int data is declared in the outer scope but goes to the inner scope of your lambda via reference. The problem is that you also have a parameter in the parameter list of your lambda called data(inner scope). This leads to a hiding of the data variable from the outer scope within the lambda.

By the way. Also your first example with function pointer should be rewritten because there is also a conflict with naming’s of identifiers in inner and outer scope. In this case it is not really bad cause effective there is only one data variable in use within the inner score. However, when parameter list variables and variables from the outer scope which calls the function have the same name this could lead to programmers confusion and should be also avoid.

Answer 2

Names from the enclosing scope of the lambda are also in the scope of the lambda.

Names that are not captured may still be used, so long as they are not odr-used. Only odr-used variables must be captured. Example:

#include <iostream>

template<typename T> void foo(const int *, T f) { std::cout << f(5) << '\n'; }

int main()
{
    const int data=0;
    foo(&data,[](int baz){
        return data;
    });
}

Because reading a constant expression is not odr-use, this code is correct and data refers to the variable in main.

This program outputs 0, but if you change int baz to int data, it outputs 5.