Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Lambda capturing constexpr object

Tags:

GCC 4.7.2 compiles this:

constexpr int i = 5; []{ std::integral_constant< int, i >(); }; // nonstandard: i not captured 

but not this:

constexpr int i = 5; [&i]{ std::integral_constant< int, i >(); }; // GCC says i not constexpr 

The latter example appears correct to me, according to C++11 §5.1.2/15:

An entity is captured by reference if it is implicitly or explicitly captured but not captured by copy. It is unspecified whether additional unnamed non-static data members are declared in the closure type for entities captured by reference.

It seems the captured object i inside the lambda refers to the variable in the enclosing scope, which is constexpr, not merely a const reference.

The standard explicitly says that the use of a by-value capture is transformed into a use of the corresponding member of the lambda object. And I think that 5.1.2 hints that my interpretation is correct.

Is there anything that explicitly says that whether a capture by reference refers to the object in the enclosing scope or a reference?

like image 269
Potatoswatter Avatar asked Nov 20 '12 08:11

Potatoswatter


People also ask

Can Lambda be constexpr?

Visual Studio 2017 version 15.3 and later (available in /std:c++17 mode and later): A lambda expression may be declared as constexpr or used in a constant expression when the initialization of each data member that it captures or introduces is allowed within a constant expression.

What is the point of constexpr?

constexpr indicates that the value, or return value, is constant and, where possible, is computed at compile time. A constexpr integral value can be used wherever a const integer is required, such as in template arguments and array declarations.


1 Answers

The second template-argument to std::integral_constant< int, i > is for a template-parameter of non-type form, specifically of integral or enumeration type (14.3.2p1 bullet 1) and so must be a converted constant expression of type int.

In a lambda-expression, implicit capture occurs when an entity is odr-used in the compound statement (5.1.2p11); use of a converted constant expression in an explicit template instantiation is not odr-use (3.2p3), so the first example is valid.

In the second example, I think gcc is incorrect to reject it; 5.1.2p17 says in a note that:

An id-expression that is not an odr-use refers to the original entity, never to a member of the closure type.

Although the paragraph as a whole is discussing capture by copy, there's no reason not to apply this rule to capture by reference as well. It's unsurprising that the standard is unclear on this; there's really no reason to capture an entity that can be used in a converted constant expression by reference.

like image 108
ecatmur Avatar answered Oct 13 '22 06:10

ecatmur