struct Test
{
static const int value = []() -> int { return 0; } ();
};
With gcc-4.6 I get something like, error: function needs to be constexpr. I have tried multiple combinations of putting constexpr at various places, but no luck.
Is constexpr supported for lambda functions as well (irrespective of return type specified or not) ? What is the correct syntax ?
Any work around possible ?
Update: As of C++17, lambdas are permitted in constant expressions.
Lambdas are currently (C++14) not allowed in constant expressions as per [expr.const]/(2.6), but they will once N4487 is accepted (which can be found in the working draft N4582):
This proposal suggests allowing lambda-expressions in constant expressions, removing an existing restriction. The authors propose that certain lambda-expressions and operations on certain closure objects be allowed to appear within constant expressions. In doing so, we also propose that a closure type be considered a literal type if the type of each of its data-members is a literal type; and, that if the
constexprspecifier is omitted within the lambda-declarator, that the generated function call operator beconstexprif it would satisfy the requirements of aconstexprfunction (similar to theconstexprinference that already occurs for implicitly defined constructors and the assignment operator functions).
constexpr is a necessary step towards making STL algorithms constexpr as well since STL algorithms frequently take lambdas as arguments. Many (all?) of them were indeed made constexpr in C++20.
From the C++0x FDIS §7.1.5[dcl.constexpr]/1:
The
constexprspecifier shall be applied only to the definition of a variable, the declaration of a function or function template, or the declaration of a static data member of a literal type.
A lambda expression is none of those things and thus may not be declared constexpr.
constexpr lambda expression? Why can you not use an ordinary function or function template?
__VA_ARGS__ of macro at run time using lambda expression. Just making it constexpr will be a compile time constant. Explaining that will be a detailed new topic. I know that there are boost alternatives available, but the method I have used seems to me very straight forward and handy.VA_NARGS and do the computation at preprocessing (see the example at the beginning of this answer).
sizeof...()? Something like template<typename... Args> Counter { static const size_t N = sizeof...(Args); };, and then use Counter<a,b,c>::N, if your macro arguments are types... or something more elaborate with constexpr size_t f(Args... args) const { return sizeof...(Args); } if your arguments aren't types.
constexpr but nothing regarding lambdas.Prior to C++17 lambdas are not compatible with constexpr. They cannot be used inside constant expressions.
Starting with C++17 lambdas are constexpr where it makes sense. The proposal N4487 will be put into the C++17 standard. On his website Herb Sutter, chair of the ISO C++ committee, stated the following:
Lambdas are now allowed inside constexpr functions.
FFWD to year 2018 :)
auto my_const_expression_lambda = []()
constexpr -> bool
{
return true ;
}
Since c++17
I know that this is an old question, but no one specified a workaround for this. The workaround is to use a constexpr functor like so:
struct functor
{
constexpr int operator()() { return 0; }
};
struct Test
{
static const int value = functor{}();
};
Not optimal as it moves the code away from where it's used, but when you don't have many options, this is doable. I had to use something similar for a project still compiling with c++14. This simple case has been tested on c++11 here: https://godbolt.org/z/Gvxq19jsd
However, if you have c++17 or higher, using the described:
struct Test
{
static constexpr int value = []() constexpr { return 0; }();
};
is a nicer option.
constexprlambda function be useful? It seems to me like it would only end up adding another pair of braces around the actual expression__VA_ARGS__in macro). But explaining that will be a whole new question.