可以“类型”吗？ lambda 表达式的表达方式？

Question

将 lambda 表达式视为可调用对象的“语法糖”，是否可以表达未命名的基础类型？

一个例子：

struct gt {
    bool operator() (int l, int r) {
        return l > r;
    }
} ;

现在，[](int l, int r) { return l >; r; } 是上述代码的优雅替代（加上必要的 gt 可调用对象的创建），但是有没有办法表达 gt （类型）本身？

一个简单的用法：

std::set<int, gt> s1;  // A reversed-order std::set
// Is there a way to do the same using a lambda?
std::set<int, some-magic-here-maybe([](int l, int r) { return l > r; }) > s2;

Answer 1

不，你不能将它放入 decltype 因为

lambda 表达式不得出现在未计算的操作数中

尽管您可以执行以下操作

auto n = [](int l, int r) { return l > r; };
std::set<int, decltype(n)> s(n);

，但这确实很难看。请注意，每个 lambda 表达式都会创建一个新的唯一类型。如果之后您在其他地方执行以下操作，t 的类型与 s 不同，

auto m = [](int l, int r) { return l > r; };
std::set<int, decltype(m)> t(m);

您可以在此处使用 std::function，但请注意，这会产生一点点运行时成本，因为它需要间接调用 lambda 函数对象调用运算符。它在这里可能可以忽略不计，但如果您想以这种方式将函数对象传递给 std::sort 例如，它可能很重要。

std::set<int, function<bool(int, int)>> s([](int l, int r) { return l > r; });

一如既往，先编码，然后分析:)

Answer 2

直接回答你的问题：不。

你需要使用可以从任何类型（类似于具有明确定义类型的函子）分配的东西。一个例子是 std::function，如 sbi 的答案所示。然而，这不是 lambda 表达式的类型。

Answer 3

从 C++ 20 开始，不带捕获的 lambda 是默认可构造的，因此可以简单地将 lambda 内联的 decltype 作为第二个模板参数传递给 std::set。

std::set<int, decltype([](int l, int r){return l > r;})> s2;

当然，在这种颠倒自然顺序的特定情况下，std::greater 更合适。

std::set<int, std::greater<>> s2;

Answer 4

您可以使用一个小类 lambda_wrapper<> 以低成本包装 lambda。它比 std::function 快得多，因为没有虚函数调用和动态内存分配。
包装器通过推导 lambda 参数列表和返回类型来工作。

#include <iostream>
#include <functional>
#include <set>

template <typename T, typename ... Args>
struct lambda_wrapper : public lambda_wrapper<decltype(&T::operator())(Args...)> {};

template <typename L>
struct lambda_wrapper<L> {
private:
    L lambda;

public:
    lambda_wrapper(const L & obj) : lambda(obj) {}

    template<typename... Args>
    typename std::result_of<L(Args...)>::type operator()(Args... a) {
        return this->lambda.operator()(std::forward<Args>(a)...);
    }

    template<typename... Args> typename
    std::result_of<const L(Args...)>::type operator()(Args... a) const {
        return this->lambda.operator()(std::forward<Args>(a)...);
    }
};
template <typename T>
auto make_lambda_wrapper(T&&t) {
    return lambda_wrapper<T>(std::forward<T>(t));
}
int main(int argc, char ** argv) 
{
    auto func = make_lambda_wrapper([](int y, int x) -> bool { return x>y; });
    std::set<int, decltype(func)> ss(func);
    std::cout << func(2, 4) << std::endl;
}

Answer 5

至少在 Microsoft Visual Studio 中（我没有在其他编译器中尝试过），如果您没有捕获任何内容，则该类型似乎是常规函数指针：

std::string (*myFunctionPointer)(int x) = [] (int x) {
  char buffer[10];
  return std::string("Test ") + itoa(x, buffer, 10);
};
std::string testOutput = myFunctionPointer(123);