C++ 提取“的签名”；“可调用的”；

我在提取函数、成员函数和lambda的签名时遇到问题。我已经编写了下面的代码来实现它，但是如果可能的话，我希望使用一个元函数来实现同样的功能。现有解决方案的问题是，lambdas不能是模板参数

template <typename R, typename ...A>
struct signature
{
};

template <typename R, typename ...A>
constexpr auto num_args(signature<R, A...> const)
{
    return sizeof...(A);
}

template <typename R, typename ...A>
constexpr auto extract_signature() noexcept
{
  return signature<R, A...>();
};

template <typename C, typename R, typename ...A>
constexpr auto extract_signature(R (C::* const)(A...)) noexcept
{
  return extract_signature<R, A...>();
}

template <typename C, typename R, typename ...A>
constexpr auto extract_signature(R (C::* const)(A...) const) noexcept
{
  return extract_signature<R, A...>();
}

template <typename R, typename ...A>
constexpr auto extract_signature(R (*const)(A...)) noexcept
{
  return extract_signature<R, A...>();
}

template <typename F>
constexpr auto extract_signature(F const& f) noexcept ->
  decltype(&F::operator(), extract_signature(&F::operator()))
{
  return extract_signature(&F::operator());
}

template <typename F>
constexpr auto extract_signature(F const& f) noexcept ->
  decltype(f(), extract_signature(f))
{
  return extract_signature(f);
}

将产生一个错误：

t.cpp:54:85: error: a lambda expression may not appear inside of a constant expression
  ::std::cout << ::std::integral_constant<::std::size_t, num_args(extract_signature([](int, int, int){}))>{} << ::std::endl;
                                                                                    ^
t.cpp:54:58: error: non-type template argument is not a constant expression
  ::std::cout << ::std::integral_constant<::std::size_t, num_args(extract_signature([](int, int, int){}))>{} << ::std::endl;
                                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
t.cpp:54:85: note: non-literal type '(lambda at t.cpp:54:85)' cannot be used in a constant expression
  ::std::cout << ::std::integral_constant<::std::size_t, num_args(extract_signature([](int, int, int){}))>{} << ::std::endl;

t.cpp:54:85:错误：lambda表达式可能不会出现在常量表达式中
：：std：：cout给定最后列出的代码段

这可以用与
std:：function
工作原理类似的方式来实现

template <typename S>
struct signature_info

template <typename R, typename A...>
struct signature_info<R(A...)>
{
  using type = signature<R, A...>;
  static const std::size_t count = sizeof...(A);
};

要获取参数的计数，
A..
，可以使用
sizeof…（A..

有一个元函数

template <typename R, typename ...A>
struct signature
{
};

template <typename S>
struct signature_info;

template <typename R, typename... A>
struct signature_info<R(A...)>
{
  using type = signature<R, A...>;
};

template <typename S>
signature_info<S> get_signature()
{
    return signature_info<S>{};
}

void func(int);

int main()
{
    auto abc = get_signature<decltype(func)>();
    cout << abc.count << endl;
    return 0;
}

以饱满的热情

#包括
#包括
#包括
使用名称空间std；
模板
结构签名
{
静态常数std:：size\u t count=sizeof…（A）；
};
模板
constexpr自动提取签名1（）无例外
{
返回签名（）；
}
模板
constexpr自动提取签名2（R（C:：*const）（A…）无例外
{
返回提取签名1（）；
}
模板
constexpr自动提取签名2（R（C:：*const）（A…）const）无例外
{
返回提取签名1（）；
}
模板
constexpr自动提取_签名（R（*const）（A…）无例外
{
返回提取签名1（）；
}
模板
constexpr自动提取_签名（F const&F）无异常->
decltype（&F:：operator（），extract_signature2（&F:：operator（））
{
返回提取签名2（&F:：operator（））；
}
int main（）
{
自动lambda=[]（int，int，int）{}；
std:：cout是的，但我脑子里有演绎。元函数可以演绎吗？当然，诀窍是为lambda获取
操作符（）
；记住lambda的类型是一个带有call操作符的类。@user1095108。我已经用一个工作示例更新了代码（已修改，但基于您的代码）对于您遇到的编译错误。“现有解决方案的问题是，lambda不能是模板参数。”--尽管lambda语法不能出现在模板参数中，但给定任何现有lambda，例如
auto lambda=[]（）{}；
，
提取\ u签名（lambda）
是完全有效的。或者至少，一旦你去掉最后一个引入无限递归的重载，它将是有效的。最后一个
extract_签名
处理什么情况（带有
decltype（f（），extract_签名（f））
）？@Niall函数指针，经过衰减后。看起来你可能想要
sizeof…（A…）
获取参数的计数
template <typename S>
struct signature_info

template <typename R, typename A...>
struct signature_info<R(A...)>
{
  using type = signature<R, A...>;
  static const std::size_t count = sizeof...(A);
};

template <typename C, typename R, typename... A>
struct signature_info<R(C::*)(A...) const>
{
  using type = signature<R, A...>;
  static const std::size_t count = sizeof...(A);
};

template <typename R, typename ...A>
struct signature
{
};

template <typename S>
struct signature_info;

template <typename R, typename... A>
struct signature_info<R(A...)>
{
  using type = signature<R, A...>;
};

template <typename S>
signature_info<S> get_signature()
{
    return signature_info<S>{};
}

void func(int);

int main()
{
    auto abc = get_signature<decltype(func)>();
    cout << abc.count << endl;
    return 0;
}

auto lambda = [](int, int, int){};
std::cout << ::std::integral_constant<::std::size_t, decltype(extract_signature(lambda))::count>{} << ::std::endl;

#include <iostream>
#include <type_traits>
#include <utility>

using namespace std;
template <typename R, typename ...A>
struct signature
{
  static const std::size_t count = sizeof...(A);
};

template <typename R, typename ...A>
constexpr auto extract_signature1() noexcept
{
  return signature<R, A...>();
}

template <typename C, typename R, typename ...A>
constexpr auto extract_signature2(R (C::* const)(A...)) noexcept
{
  return extract_signature1<R, A...>();
}

template <typename C, typename R, typename ...A>
constexpr auto extract_signature2(R (C::* const)(A...) const) noexcept
{
  return extract_signature1<R, A...>();
}

template <typename R, typename ...A>
constexpr auto extract_signature(R (*const)(A...)) noexcept
{
  return extract_signature1<R, A...>();
}

template <typename F>
constexpr auto extract_signature(F const& f) noexcept ->
  decltype(&F::operator(), extract_signature2(&F::operator()))
{
  return extract_signature2(&F::operator());
}

int main()
{
    auto lambda = [](int, int, int){};
    std::cout << ::std::integral_constant<::std::size_t, decltype(extract_signature(lambda))::count>{} << ::std::endl;
}