推导成员函数参数/返回类型

Question

I have the following code:

template <class... Args>
struct TypeList
{
    static constexpr size_t size = sizeof...(Args);

    template <std::size_t N>
    using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
};

struct Generator
{
    std::tuple<float, float> process(float, int, size_t)
    {
        return std::make_tuple(0.0f, 1.0f);
    }
};

Is there any way to deduce both the tuple template arguments as well as the input arguments for Generator::process in order to construct a class that has the following template arguments.

struct Node<GenType, ReturnTypesList, ArgumentTypeList>

Where ReturnTypesList contains template arguments of the returned tuple and ArgumentTypeList contains the variadic argument types of the process function. It is assumed that all process functions will return a tuple.

Answer 1

I didn't get exactly what you are looking for, but probably something like this would work for you:

#include <type_traits>
#include <tuple>

template <class... Args>
struct TypeList
{
    static constexpr size_t size = sizeof...(Args);

    template <std::size_t N>
    using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
};

struct Generator
{
    std::tuple<float, float> process(float, int, size_t)
    {
        return std::make_tuple(0.0f, 1.0f);
    }
};

template<typename GenType, typename ReturnTypesList, typename ArgumentTypeList>
struct Node {};

template<typename T>
struct S
{
    template<typename... RArgs, typename... Args>
    static auto gen(std::tuple<RArgs...>(T::*)(Args...)) -> Node<T, TypeList<RArgs...>, TypeList<Args...>>;
};

template<typename T>
using NodeType = decltype(S<T>::gen(&T::process));

int main()
{
    static_assert(std::is_same<NodeType<Generator>,  Node<Generator, TypeList<float, float>, TypeList<float, int, size_t>>>::value, "!");
}

NodeType is the required type once specialized with the specific generator, as you can see from the test in the main .
In the specific case:

Node<Generator, TypeList<float, float>, TypeList<float, int, size_t>>

Don't mind if the member is provided as a function parameter instead of a template argument. The whole thing is solved at compile-time anyway.

As a side note, the solution won't work for those generators that have overloaded process .

Answer 2

#include <tuple>

template <class...>
struct Node;

struct Generator {
  std::tuple<float, float> process(float, int, size_t);
};

template <class... Args1, class ClassType, class... Args2>
auto foo(std::tuple<Args1...> (ClassType::*)(Args2...)) -> Node<ClassType, Args1..., Args2...>;



int main() {

  // T is Node<Generator, float, float, float, int, size_t>
  using T = decltype(foo(&Generator::process));

  return 0;
}

Args1 and Args2 are deduced properly because the pack expansion that appears at the very end of the template parameter list will be deduced. And the member function pointer which is passed to foo contains all the types necessary. All the template parameters of foo will be deduced separately and then combined to a type which match the type of &Generator::process after certain adjustment. Link

Unrelated: If process isn't garanted to return a std::tuple , we can still use a template template parameter, aka template <class...> class TT

Edit according to the information provided by @Martin Bonner

template <class...>
struct Node {};

template <class...>
struct TypeList {};

struct Generator {
  std::tuple<float, float> process(float, int, size_t) {}
};

template <class... ReturnArgs, class GeneratorType, class... Args>
auto magic(std::tuple<ReturnArgs...> (GeneratorType::*arg)(Args...))
    -> Node<GeneratorType, TypeList<ReturnArgs...>, TypeList<Args...> > {
  using ReturnType =
      Node<GeneratorType, TypeList<ReturnArgs...>, TypeList<Args...> >;

  return ReturnType{};
}

int main() {
  magic(&Generator::process);

  return 0;
}