Calling `this` member function from generic lambda - clang vs gcc

Question

Issue: passing a generic lambda (to a template function) that captures this and calls a member function of this without an explicit this-> does not compile on gcc. If the lambda is not generic, or if the lambda is not passed to any other function but called in place, it compiles withoit an explicit this->. Clang is cool with the code in all situations.

Time for another round of clang vs gcc. Who's right?

Wandbox example

template<typename TF>
void call(TF&& f)
{
    f(1);   
}

struct Example
{        
    void foo(int){ }

    void bar()
    {
        call([this](auto x){ foo(x); });
    }
};

int main()
{
    Example{}.bar();
    return 0;
}

With bar() = call([this](auto x){ foo(x); });
- clang++ 3.6+ compiles.
- g++ 5.2+ does not compile.
  
  error: cannot call member function 'void Example::foo(int)' without object call([this](auto x){ foo(x); });`

With bar() = call([this](auto x){ this->foo(x); });
- clang++ 3.6+ compiles.
- g++ 5.2+ compiles.

With bar() = call([this](int x){ foo(x); });
- clang++ 3.6+ compiles.
- g++ 5.2+ compiles.

With bar() = [this](auto x){ foo(x); }(1);
- clang++ 3.6+ compiles.
- g++ 5.2+ compiles.

Why is the this-> necessary only in the case of a generic lambda?

Why is the this-> not necessary if the lambda isn't passed to call?

Who is being non standard-compliant?

The inconsistencies you note indicate that clang is correct here. — Cheers and hth. - Alf
– Cheers and hth. - Alf, Commented Aug 19, 2015 at 14:07
Without even looking at the standard, I can say with absolute certainty that Clang is right. Even if it disagrees with the standard, it's still right; in that case the standard is wrong. GCC's behavior makes absolutely no sense whatsoever. — Sebastian Redl
– Sebastian Redl, Commented Aug 19, 2015 at 14:07
MSVC Community 2015 RC V14.0.22823.1 Will compile all cases as well — NathanOliver
– NathanOliver, Commented Aug 19, 2015 at 14:14

Barry · Accepted Answer · 2015-08-19 14:50:01Z

20

This is a gcc bug. From [expr.prim.lambda]:

The lambda-expression’s compound-statement yields the function-body (8.4) of the function call operator, but for purposes of name lookup (3.4), determining the type and value of this (9.3.2) and transforming id-expressions referring to non-static class members into class member access expressions using (*this) (9.3.1), the compound-statement is considered in the context of the lambda-expression. [ Example:
struct S1 {
    int x, y;
    int operator()(int);
    void f() {
        [=]()->int {
            return operator()(this->x + y); 
                // equivalent to S1::operator()(this->x + (*this).y)
                // this has type S1*
        };
    }
};
—end example ]

Since in your example you capture this, the name lookup should include class members of Example, which should therefore find Example::foo. The lookup performed is identical to what would happen if foo(x) appeared in the context of the lambda-expression itself, that is if the code looked like:

void bar()
{
    foo(x); // clearly Example::foo(x);
}

At least this bug has a very simple workaround as indicated in the question: just do this->foo(x);.

answered Aug 19, 2015 at 14:50

Barry

312k32 gold badges735 silver badges1.1k bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

jotik Over a year ago

Is there an upstream bug report to track this?

Barry Over a year ago

@jotik Yeah, OP reported it.

Collectives™ on Stack Overflow

Calling `this` member function from generic lambda - clang vs gcc

1 Answer 1

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related