Determining the Parameter Types of an Undefined Fu

Question

I've recently learned that I cannot:

1. Take the address of an undefined function
2. Take the address of a templatized function with a type it would fail to compile for

But I've also recently learned that I can call decltype to get the return type of said function

So an undefined function:

int foo(char, short);

I'd like to know if there's a way that I can match the parameter types to the types in a tuple. This is obviously a meta programming question. What I'm really shooting for is something like decltypeargs in this example:

enable_if_t<is_same_v<tuple<char, short>, decltypeargs<foo>>, int> bar;

Can anyone help me understand how decltypeargs could be crafted?

Answer 1

For non-overloaded functions, pointers to functions, and pointers to member functions, simply doing decltype(function) gives you the type of the function in an unevaluated context, and that type contains all the arguments.

So to get the the argument types as a tuple, all you need are a lot of specializations:

// primary for function objects
template <class T>
struct function_args
: function_args<decltype(&T::operator()>
{ };

// normal function
template <class R, class... Args>
struct function_args<R(Args...)> {
    using type = std::tuple<Args...>;
};

// pointer to non-cv-qualified, non-ref-qualified, non-variadic member function
template <class R, class C, class... Args>
struct function_args<R (C::*)(Args...)>
: function_args<R(Args...)>
{ };

// + a few dozen more in C++14
// + a few dozen more on top of that with noexcept being part of the type system in C++17

With that:

template <class T>
using decltypeargs = typename function_args<T>::type;

This requires you to write decltypeargs<decltype(foo)>.

---

With C++17, we will have template <auto>, so the above can be:

template <auto F>
using decltypeargs = typename function_args<decltype(F)>::type;

and you'd get the decltypeargs<foo> syntax.