c++ - 基于 lambda arity 的特化函数模板

Question

我正在尝试根据作为参数传递给它的 lambda 的元数来专门化模板函数。这是我想出的解决方案:

template<typename Function, bool>
struct helper;

template<typename Function>
struct helper<Function, false>
{
    auto operator()(Function&& func)
    {
        std::cout << "Called 2 argument version.\n";
        return func(1, 2);
    }
};

template<typename Function>
struct helper<Function, true>
{
    auto operator()(Function&& func)
    {
        std::cout << "Called 3 argument version.\n";
        return func(1, 2, 3);
    }
};

template<typename T>
struct B
{
    T a;
    const T someVal() const { return a; }
};

template<typename Function, typename T>
auto higherOrderFun(Function&& func, const T& a)
{
    return helper<Function, std::is_invocable<Function, decltype(a.someVal()), decltype(a.someVal()), decltype(a.someVal())>::value>{}(std::forward<Function>(func));
}


int main()
{
    B<int> b;
    std::cout << higherOrderFun([](auto x, auto y) {return x+y; }, b) << "\n";
    std::cout << higherOrderFun([](auto x, auto y, auto z) {return x + y+z; }, b) << "\n";
    return 0;
}

有没有办法以更优雅的方式实现这一点？我看过这个:Arity of a generic lambda

但是，最新的解决方案 (florestan's) 将所有参数转换为 aribtrary_t，因此必须将它们转换回每个 lambda 内部，我认为这并不理想。理想情况下，我希望直接使用 SFINAE 专门化模板化 higherOrderFun，但实际上我使用了一个辅助类来实现它。有没有更直接的方法？例如，将 SFINAE 直接应用于 higherOrderFun 而不依赖于 helper 类？这样做的重点是不必将 higherOrderFun 更改为 higherOrderFun2 和 higherOrderFun3，而是让编译器从 lambda 中推断出正确的特化和给定的参数 (const T& a)。

我应该提一下，我也不关心函数参数的类型——只关心它们的数量，所以我会把 decltype(a.someVal()) 改成 auto 在我的示例中，如果可能的话(也许有一种方法可以避免显式定义类型？)。

Answer 1

以下模板为我提供了 lambda 的参数数量，a std::function ，或一个普通的函数指针。这似乎涵盖了所有基础知识。所以，你专注于n_lambda_parameters<T>::n ，并将其插入您的模板。根据您的具体用例，您可能需要使用 std::remove_reference_t 提供的工具或 std::decay_t , 包装这个。

使用 g++ 9 测试。需要 std::void_t来自 C++17，大量模拟 std::void_t 的例子pre C++17 可以在别处找到...

#include <functional>

// Plain function pointer.

template<typename T> struct n_func_parameters;

template<typename T, typename ...Args>
struct n_func_parameters<T(Args...)> {

    static constexpr size_t n=sizeof...(Args);
};

// Helper wrapper to tease out lambda operator()'s type.

// Tease out closure's operator()...

template<typename T, typename> struct n_extract_callable_parameters;

// ... Non-mutable closure
template<typename T, typename ret, typename ...Args>
struct n_extract_callable_parameters<T, ret (T::*)(Args...) const> {

    static constexpr size_t n=sizeof...(Args);
};

// ... Mutable closure
template<typename T, typename ret, typename ...Args>
struct n_extract_callable_parameters<T, ret (T::*)(Args...)> {

    static constexpr size_t n=sizeof...(Args);
};

// Handle closures, SFINAE fallback to plain function pointers.

template<typename T, typename=void> struct n_lambda_parameters
    : n_func_parameters<T> {};

template<typename T>
struct n_lambda_parameters<T, std::void_t<decltype(&T::operator())>>
    : n_extract_callable_parameters<T, decltype(&T::operator())> {};


#include <iostream>

void foo(int, char, double=0)
{
}

int main()
{
    auto closure=
        [](int x, int y)
    // With or without mutable, here.
        {
        };

    std::cout << n_lambda_parameters<decltype(closure)>::n
          << std::endl; // Prints 2.

    std::cout << n_lambda_parameters<decltype(foo)>::n
          << std::endl; // Prints 3.

    std::cout << n_lambda_parameters<std::function<void (int)>>::n
          << std::endl; // Prints 1.
    return 0;
}