Question

I’ve written some code using lambda on vc2010. The simplified structure of code is like below:

template<typename Functor>
bool f1(int a, Functor& f)
{
    return f(a+1);
}

template<typename Functor>
bool f2(Functor& f)
{
    return f(1);
}

template<typename Functor>
bool f3(Functor& f)
{
    return f2([&](int a) -> bool {
        // (1) Works
        auto test = [&](int b) -> bool { return f(a+b); };
        return f1(a, test);

        // (2) Doesn't work         
        //return f1(a, [&](int b) -> bool { return f(a+b); });
    });
};

int main()
{
    int a = 100;

    f3([&](int b) { return (a+b)%2 == 0; });
}

First I wrote a nested lambda code as (2), and vc10 gives a incomprehensible error message like below

'f1' : cannot convert parameter number from 'int' to 'int &'

However code (1) works well, which is indentical to (2) except lvalue-ness.

My question is:

1. Is code (2) conforming C++11 standard?
2. If not, what’s the reason of this strange compilation behavior?

Answer 1

return f1(a, [&](int b) -> bool { return f(a+b); });

Here, the second argument which is a lambda, is a temporary object which cannot be bound to non-const reference. I believe, the error message is misleading; it doesn’t exactly tell the problem. A good compiler will print better error message. Try GCC, or Clang.

The fix is this: make the second argument non-reference:

template<typename Functor>
bool f1(int a, Functor f)  //I removed `&` from the second parameter
{
    return f(a+1);
}

Likewise, make all the Functor parameters in other functions non-reference. Passing functor as reference doesn’t make much sense, especially in C++11, in which you can pass lambda as well which you can define on the fly.