C++ 使用模板元编程检测函数可以接受的最大参数数

考虑以下代码：

template <class T, class F>
std::size_t maximum_number_of_arguments(F&& f) {
    // Code here
}

因此：

maximum_number_of_arguments<int>(f)

---

你问的并不是那么简单

如果您对仅可用于调用具有公共标识符的函数或函数集的最大整数数感兴趣，不包括其他类型的调用

我是说。。。如果需要检查以下一组

f（）

函数

void f(int, int); 
void f(int, char, int);
void f(int, std::string, int, int, int); // excluded by std::string

应获取

3

，因为将排除接收

std:：string

的版本

嗯。。。使用一个宏（因此我的解决方案是内在的邪恶）定义一个专用于符号的检查结构

setMaxStruct(f);

您可以通过以下方式获得整数参数的最大数量（具有可设置但默认的最大值）

std::cout << "--- f: " << getMaxArgsFor_f<int>::value << std::endl;

---

std:：cout对于
printf
？或者
template void foo（T…）
“我想要一个可以找到最大数量的类型参数的函数…”为什么？用例是什么？这并不好笑，但闻起来像是一个x-y问题。看起来你实际上是在问如何隐式传递一组重载。否则，确定重载集中每个函数的参数数量，然后选择最大值将很容易。您想要做的是不可能的。如果不知道函数的确切类型，就不能将
f
传递给函数，因为它是重载集的一部分。如果你知道它的类型，你就有了参数的数量。
setMaxStruct(f);

std::cout << "--- f: " << getMaxArgsFor_f<int>::value << std::endl;

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

template <typename T, std::size_t>
using typer = T;

#define setMaxStruct(func)                                        \
                                                                  \
template <typename Type, std::size_t MaxArgs = 64U>               \
struct getMaxArgsFor_ ## func                                     \
 {                                                                \
   template <typename, std::size_t ...>                           \
   static std::false_type isCallable (...);                       \
                                                                  \
   template <typename T, std::size_t ... Is>                      \
   static auto isCallable (int)                                   \
      -> decltype( func(std::declval<typer<T, Is>>()...),         \
                   std::true_type{} );                            \
                                                                  \
   template <typename T, std::size_t ... Is>                      \
   static constexpr bool getMaxTH3                                \
      (std::index_sequence<Is...> const &)                        \
    { return decltype(isCallable<T, Is...>(0))::value; }          \
                                                                  \
   template <typename T, std::size_t I>                           \
   static constexpr bool getMaxTH2 ()                             \
    { return getMaxTH3<T>(std::make_index_sequence<I>{}); }       \
                                                                  \
   template <typename T, std::size_t ... Is>                      \
   static constexpr std::size_t getMaxTH1                         \
      (std::index_sequence<Is...> const &)                        \
    {                                                             \
      std::size_t ret ( -1 );                                     \
                                                                  \
      ( (ret = getMaxTH2<T, Is>() ? Is : ret), ...);              \
                                                                  \
      return ret;                                                 \
    }                                                             \
                                                                  \
   template <typename T, std::size_t MaxAs>                       \
   static constexpr std::size_t getMaxT ()                        \
    { return getMaxTH1<T>(std::make_index_sequence<MaxAs>{}); }   \
                                                                  \
   static constexpr std::size_t value = getMaxT<Type, MaxArgs>(); \
 }

void f(int, int);
void f(int, int, int);
void f(int, char, int, double);
void f(int, std::string, int, int, int);

template <typename ... Args>
void h (Args ... args);

setMaxStruct(f);
setMaxStruct(g);
setMaxStruct(h);

int main()
 {
   std::cout << "--- f: " << getMaxArgsFor_f<int>::value << std::endl;
   std::cout << "--- g: " << getMaxArgsFor_g<int>::value << std::endl;
   std::cout << "--- h: " << getMaxArgsFor_h<int>::value << std::endl;
 }