c – 使用可变参数模板参数来解析lambda签名

Per [expr.prim.lambda] / 3,lambda-expression的类型是类类型,就像“普通的,命名的函数对象类型”一样：

The type of the lambda-expression (which is also the type of the closure object) is a unique,unnamed non-union class type — called the closure type […]

再往下,/ 5指定：

The closure type for a lambda-expression has a public inline function call operator (13.5.4) whose parameters and return type are described by the lambda-expression’s parameter-declaration-clause and trailing-return-type respectively. This function call operator is declared const (9.3.1) if and only if the lambda-expression’s parameter-declaration-clause is not followed by mutable. It is neither virtual nor declared
volatile. […]

(然后通过指定属性和异常规范继续)

这意味着lambda [](int p){return p / 2.0;在这方面表现得很像

struct named_function_object
{
    double operator() (int p) const { return p/2.0; }
};

因此,你的第一次专业化

template<typename R,typename...As>
struct invokable_type<R(As...)>;

应该已经能够处理lambdas了. SSCCE

#include <utility>

template<class T>
struct decompose;

template<class Ret,class T,class... Args>
struct decompose<Ret(T::*)(Args...) const>
{
    constexpr static int n = sizeof...(Args);
};

template<class T>
int deduce(T t)
{
    return decompose<decltype(&T::operator())>::n;
}

struct test
{
    void operator() (int) const {}
};

#include <iostream>
int main()
{
    std::cout << deduce(test{}) << std::endl;
    std::cout << deduce([](int){}) << std::endl;
}

在最新版本的clang和g上编译好.似乎问题与g 4.7有关

进一步的研究表明,g -4.7.3编译了上述例子.

问题可能与lambda表达式产生函数类型的误解有关.如果我们将do_something定义为

template<class C>
void do_something(C&&)
{
    std::cout << invokable_type<C>::n << std::endl;
}

然后对于像do_something([](int){})这样的调用,模板参数C将被推导为闭包类型(无引用),即类类型.上面定义的结构测试的类似情况是do_something(test {}),在这种情况下,C将被推导出来进行测试.

因此,实例化的invokable_type的特化是一般情况

template<class T>
struct invokable_type;

因为在这两种情况下T都不是像指针或函数类型那样的“复合类型”.这种一般情况可以通过假设它只采用纯类类型,然后使用该类类型的成员T :: operator()来使用：

template<class T>
struct invokable_type
{
    constexpr static int n = invokable_type<&T::operator()>::n;
};

或者,正如Potatoswatter所说,通过继承

template<class T>
struct invokable_type
    : invokable_type<&T::operator()>
{};

然而,Potatoswatter’s version更通用,可能更好,依赖于SFINAE检查T :: operator()的存在,如果找不到运算符,它可以提供更好的诊断消息.

注：如果为lambda表达式添加前缀,该表达式不会捕获带有一元的任何内容,则它将转换为指向函数的指针. do_something([](int){})将使用特殊化invokable_type< Return(*)(Args ...)>.