C++ Defining a (static) lambda function inside a class

Question

Here's the starting point for my question. Some code which does not compile.

class MyClass
{

    // for sorting
    auto lambda = [](const auto& x, const auto& y)
    {
        return x.x < y.x;
    };

    // something that needs a custom way to sort
    std::set<SomeOtherClass, lambda> mySet;

};

The error produce by the compiler is

error: non-static data member declared with placeholder ‘auto’
auto databaseSortLambda = +[](const auto& x, const auto &y)

It looks like a simple fix. Put static in there somewhere. My understanding is that this won't work, because this defines a static variable called lambda which has the type "closure object", rather than the lambda function itself being a static function.

class MyClass
{

    // for sorting
    static auto lambda = [](const auto& x, const auto& y)
    {
        return x.x < y.x;
    };

    // something that needs a custom way to sort
    std::set<SomeOtherClass, lambda> mySet;

};

This produces the following compiler error:

error: ‘constexpr’ needed for in-class initialization of static data member ‘MyClass::<lambda(const auto:1&, const auto:2&)> MyClass::lambda’ of non-integral type

The question is why? My understanding of constexpr is that it tells the compiler that it should calculate the result of an expression, and use that rather than calculating the expression at runtime.

In this case, how can this lambda be a constexpr ? Surely the value of xx < yx cannot be known until runtime?

Is the compiler just telling me something meaningless at this point? And is there a way to write my lambda as a "static function" inside the class?

Answer 1

There are two things that can be meant when one says that the lambda is constexpr .

There may be a constexpr qualifier on the lambda expression itself. This determines whether the operator() of the closure type generated from the lambda expression is constexpr -qualified (although it will be constexpr -qualified even without that specifier if the operator() would satisfy the requirements for a function (template) to be constexpr -qualified).

The other is that the variable to which you store the lambda is constexpr -qualified. This has nothing to do with the the operator() of the closure type or equivalently its body. Instead it determines whether the lambda object itself is const and initialized by a constant expression.

A lambda that doesn't have any capture doesn't need to perform any action to be initialized. The lambda expression itself can be used in a constant expression (since C++17) and so there is nothing disqualifying the initializer from being a constant expression:

// for sorting
constexpr static auto lambda = [](const auto& x, const auto& y)
{
    return x.x < y.x;
};

Alternatively inline would also work.