C++ 函数参数的decltype

是否可以推断函数参数的类型？例如，如果我有：

void foo(int a);

我想推断类型

int

是

foo

的第一个参数的类型。一种可能的用途是：

foo( static_cast< decltype(/* ??? foo's first param ??? */) >(value) );

foo（static_cast（value））；

在中，函数具有相同类型的成员进行推断，因此它不会直接推断函数参数类型

是否可以推断函数参数的类型

当然

通过示例（

argType

）

模板
结构argType；
模板
结构argType
{使用类型=A；}；
无效foo（int a）
{ }
int main（）
{
长值=1L；
foo（静态_cast（值））；
}

如果您使用的是更通用的解决方案，下面的示例将显示如何创建和使用类型traits来检测返回类型或第n个参数类型

#include <string>

template <std::size_t N, typename T0, typename ... Ts>
struct typeN
 { using type = typename typeN<N-1U, Ts...>::type; };

template <typename T0, typename ... Ts>
struct typeN<0U, T0, Ts...>
 { using type = T0; };

template <std::size_t, typename>
struct argN;

template <std::size_t N, typename R, typename ... As>
struct argN<N, R(As...)>
 { using type = typename typeN<N, As...>::type; };

template <typename>
struct returnType;

template <typename R, typename ... As>
struct returnType<R(As...)>
 { using type = R; };

long bar (int a, std::string const &)
 { return a; }

int main()
 {
   long         valI = 1L;
   char const * valS = "abc";

   bar( static_cast<typename argN<0U, decltype(bar)>::type>(valI),
        static_cast<typename argN<1U, decltype(bar)>::type>(valS) );

   static_assert(
      std::is_same<long,
                   typename returnType<decltype(bar)>::type>::value, "!");
 }

#包括
模板
结构类型
{using type=typename typeN:：type；}；
模板
结构类型
{使用类型=T0；}；
模板
结构参数；
模板
结构参数
{using type=typename typeN:：type；}；
模板
结构返回类型；
模板
结构返回类型
{使用type=R；}；
长条形图（int a，std:：string const&）
{返回a；}
int main（）
{
长有效期=1L；
字符常量*valS=“abc”；
棒材（静态铸造（valI），
静态铸型（VAL）；
静态断言(
std:：is_same:：value，“！”；
}

稍微概括一下：

template struct FirstArgument；
模板
结构第一参数
{
使用类型=A；
};
模板
使用first\u agument\u t=typename FirstArgument:：type；
void foo（int a）{}
空条（inta，double b）{}
int main（）
{
长值=1L；
foo（静态_cast（值））；
棒（静态_铸造（值），0）；
}

，不确定是否完全重复，因此未将其标记为完全重复。查找函数特征。@nosensetal-是，但lambda不是函数。如果lambda可转换为函数指针，则可以使用

decltype（+baz）

，（其中

baz

是可转换的lambda），但必须修改

returnType

和

argN

，才能与函数指针一起工作。

#include <string>

template <std::size_t N, typename T0, typename ... Ts>
struct typeN
 { using type = typename typeN<N-1U, Ts...>::type; };

template <typename T0, typename ... Ts>
struct typeN<0U, T0, Ts...>
 { using type = T0; };

template <std::size_t, typename>
struct argN;

template <std::size_t N, typename R, typename ... As>
struct argN<N, R(As...)>
 { using type = typename typeN<N, As...>::type; };

template <typename>
struct returnType;

template <typename R, typename ... As>
struct returnType<R(As...)>
 { using type = R; };

long bar (int a, std::string const &)
 { return a; }

int main()
 {
   long         valI = 1L;
   char const * valS = "abc";

   bar( static_cast<typename argN<0U, decltype(bar)>::type>(valI),
        static_cast<typename argN<1U, decltype(bar)>::type>(valS) );

   static_assert(
      std::is_same<long,
                   typename returnType<decltype(bar)>::type>::value, "!");
 }

template <typename> struct FirstArgument;

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

template <typename T>
using first_agument_t = typename FirstArgument<T>::type;

void foo(int a){ }

void bar(int a, double b){ }

int main()
{
   long value = 1L;
   foo(static_cast<first_agument_t<decltype(foo)>>(value) );
   bar(static_cast<first_agument_t<decltype(bar)>>(value), 0);
}