Does C++11 require this lambda to be declared mutable?

Question

Consider this C++11 code:

#include <functional>
#include <cstdlib>

template <typename F>
void test(F &&f) {
    auto foo = [f]() {
        f();
    };
    foo();
}

int main() {
    test(std::bind(std::puts, "hello"));
    return 0;
}

GCC and Clang accept this as valid C++11 code, but Visual Studio 2013 requires the lambda to be declared mutable (auto foo = [f]() mutable { ... }). Otherwise I get this error:

error C3848: expression having type 'const std::_Bind<true,int,int (__cdecl *const )(const char *),const char (&)[6]>' would lose some const-volatile qualifiers in order to call 'int std::_Bind<true,int,int (__cdecl *const )(const char *),const char (&)[6]>::operator ()<>(void)'

Is Visual Studio right to reject this code without mutable, or is it valid C++11?

(Curiously Clang rejects the code if you change std::bind(std::puts, "hello") to std::bind(std::exit, 0) apparently because it considers noreturn to make the function type different; I'm quite sure this is a bug.)

user743382 · Accepted Answer · 2014-09-24 13:09:30Z

14

This isn't really about lambdas.

#include <functional>
#include <cstdlib>

int main() {
  const auto x = std::bind(std::puts, "hello");
  x();
}

This is accepted by GCC, but rejected by MSVC.

The standard is unclear on whether this is valid, IMO. The return value g of std::bind has an unspecified return type for which g(...) is valid and defined in terms of the cv-qualifiers of g, but the standard doesn't actually say that any operator() must be callable for const-qualified objects or references. It strongly implies that this is intended to be valid, because otherwise the reference to g's cv-qualifiers seems useless, but it doesn't actually say it is valid.

Because of that, I think MSVC's behaviour is not what the standard's authors intended, but it may nonetheless conform to what the standard requires.

answered Sep 24, 2014 at 13:09

user743382

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

5 Comments

Mike Seymour Over a year ago

No, it doesn't conform to the standard. "The effect of g(u1, u2, ..., uM) shall be INVOKE (fd, v1, v2, ..., vN, result_of<FD cv (V1, V2, ..., VN)>::type)" means that the result of bind must be callable if the bound function object is. The function pointer is callable whether or not it's const, so the bind thing must also be.

user743382 Over a year ago

@MikeSeymour g is the return value of std::bind, and only g(...)'s behaviour is specified. Where does the standard require supporting calls through a const-qualified reference to that return value?

Mike Seymour Over a year ago

In the quote I gave above (20.8.9.1.2/3), plus the following clause "where cv represents the cv-qualifiers of g". Calling g has the same effect as invoking fd (the bound function object) with the cv-qualifiers of g applied to fd; so a call to a const-qualified copy/reference of g must be valid if an invocation of const FD is. Here, FD is a function pointer type, which is callable whether or not it's const.

user743382 Over a year ago

@MikeSeymour g is the forwarding wrapper returned by bind, and only g is required to be callable. When you add cv-qualifiers, you've no longer got g. Again, it's almost certainly intended to be valid, but the standard doesn't actually say so.

Mike Seymour Over a year ago

OK, I suppose an ultra-pedantic reading could be that the behaviour of copies or references isn't properly specified. I should know better than to get involved with language-lawyer discussions.

Mike Seymour · Accepted Answer · 2014-09-24 13:14:09Z

10

This looks like a bug in the Visual Studio implementation of bind, returning a type with only a non-const function call operator. It should return a type that forwards all function calls to the bound function object, regardless of its own cv-qualifications.

To summarise the rather opaque language of C++11 20.8.9.1.2, function calls on the result of bind should be forwarded to the bound function object, and so should be allowed if calls on that object would be allowed. So it would be an error if the bound function object weren't callable if const; but here, being a function pointer, it is callable regardless of cv-qualifications.

answered Sep 24, 2014 at 13:14

Mike Seymour

256k30 gold badges467 silver badges658 bronze badges

Collectives™ on Stack Overflow

Does C++11 require this lambda to be declared mutable?

2 Answers 2

5 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related