decltype of function parameter

Question

Is it possible to deduce the type of a function parameter? For example, if I have:

void foo(int a);

I would like to deduce the type int as the type of foo's first parameter. A possible use could be:

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

In this related question, the answers exploit having a member with the same type for deduction, so it does not directly deduce the function parameter type.

[Related](http://stackoverflow.com/questions/22632236/how-is-possible-to-deduce-function-argument-type-in-c), not sure if exact duplicate, so didn't mark it as such. — Algirdas Preidžius, Apr 20 '17 at 18:03
It does appear to be a duplicate, although the answer here is better. — Jake Cobb, Dec 17 '21 at 15:01

max66 · Accepted Answer · 2017-04-20T18:54:22.450

Is it possible to deduce the type of a function parameter?

Sure.

With a type traits, by example (argType)

template <typename>
struct argType;

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


void foo(int a)
 { }

int main()
 {
   long value = 1L;

   foo( static_cast<typename argType<decltype(foo)>::type>(value) );
 }

If you're interrested in a little more generic solution, the following example show how create and use a type traits to detect the return type or the n-th argument type

#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, "!");
 }

@NoSenseEtAl - Yes, but lambdas aren't functions. When you have a lambda that is convertible to a function pointer, you can use something as `decltype(+baz)`, (where `baz` is the convertible lambda) but you have to modify `returnType` and `argN` to works (also?) with function pointers. — max66, Apr 03 '19 at 07:47

score 9 · Answer 2 · edited May 23 '17 at 11:55

9

A slightly generalized version of the answer by @max66:

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);
}

edited May 23 '17 at 11:55

Community

1
1

answered Apr 20 '17 at 18:11

R Sahu

204,454
14
159
270

I don't quite understand the syntax when the `T` in `first_agument_t` is deduced into `R` `A` `Args` in `FirstArgument`, any link to this syntax? – Felix F Xu Jun 06 '23 at 14:15

decltype of function parameter

2 Answers2

Linked