Как передать пакеты параметров в С++?

Рассмотрим следующий пример:

template <class T> class method_traits;
template <class T, class Ret, class... Arg> class method_traits<Ret(T::*)(Arg...)> {
public:
    using type = Arg; // this does not work
};

template <class T> using argument_types = typename method_traits<T>::type;

template <class T> class Node {
    T t;
public:
    Node(Input<argument_types<decltype(&T::process)>>... inputs) { // how do I make this work?
        ...
    }
};

Аргументы конструктора Node<T> зависят от аргументов метода T::process. Поэтому, если тип T имеет метод process подписи float process(float a, int b), подпись конструктора Node<T> должна выглядеть так: Node(Input<float> a, Input<int> b).

Как извлечь пакет параметров из T::process, чтобы использовать его в конструкторе Node?

ОТВЕТЫ

Ответ 1

Очевидно, что вы не можете сохранить список типов таким образом.

    using type = Arg;

где Arg - вариационный список типов.

Но вы можете сохранить их в контейнере типов и std::tuple может это сделать тоже. Поэтому я предлагаю изменить специализацию method_traits следующим образом

template <typename T>
struct method_traits;

template <typename T, typename Ret, typename... Args>
struct method_traits<Ret(T::*)(Args...)>
 { using tTypes = std::tuple<Args...>; };

и перепишите argument_types, чтобы перехватить std::tuple

template <typename T>
using tTypes = typename method_traits<T>::tTypes;

Теперь вы можете использовать значение шаблона по умолчанию и трюк частичной специализации, определяющий node

template <typename T, typename TArgs = tTypes<decltype(&T::process)>>
struct Node;

Таким образом, создавая экземпляр объекта Node<T>, вы фактически получаете Node<T, tTypes<decltype(&T::process)>, который является Node<T, std::tuple<Args...>> с нужным Args....

Итак, вы можете просто определить следующую частичную специализацию Node следующим образом

template <typename T, typename ... Args>
struct Node<T, std::tuple<Args...>>
 {
   T t;

   Node (Input<Args> ... inputs)
    { /* do something */ }
 };

Ниже приведен полный рабочий пример

#include <tuple>
#include <type_traits>

template <typename T>
struct tWrapper
 { using type = T; };

template <typename T>
using Input = typename tWrapper<T>::type;

template <typename T>
struct method_traits;

template <typename T, typename Ret, typename... Args>
struct method_traits<Ret(T::*)(Args...)>
 { using tTypes = std::tuple<Args...>; };

template <typename T>
using tTypes = typename method_traits<T>::tTypes;

template <typename T, typename TArgs = tTypes<decltype(&T::process)>>
struct Node;

template <typename T, typename ... Args>
struct Node<T, std::tuple<Args...>>
 {
   T t;

   Node (Input<Args> ... inputs)
    { /* do something */ }
 };

struct foo
 {
   float process (float a, int b)
    { return a+b; }
 };

int main ()
 {
   Node<foo> nf(1.0f, 2);
 }

- EDIT -

Как указано Julius (и самими OP), для этого решения требуется дополнительный тип шаблона со значением шаблона по умолчанию.

В этом упрощенном случае это не проблема, но я могу представить обстоятельства, при которых этот дополнительный аргумент шаблона не может быть добавлен (например: if Node получить вариационный список аргументов шаблона).

В этих случаях Julius предлагает способ, который немного усложняет решение, но позволяет избежать дополнительного параметра шаблона для Node: добавить базовый класс шаблона, который получает аргументы TArgs, и работает с конструктором наследование.

То есть: определение a NodeBase следующим образом

template <typename, typename>
struct NodeBase;

template <typename T, typename ... Args>
struct NodeBase<T, std::tuple<Args...>>
 {
   T t;

   NodeBase (Input<Args> ...)
    { /* do something */ }
 };

нет необходимости в дополнительном параметре шаблона для Node, который может быть просто записан как

template <typename T>
struct Node
   : public NodeBase<T, tTypes<decltype(&T::process)>>
 { using NodeBase<T, tTypes<decltype(&T::process)>>::NodeBase; };

Юлий, следуя этой идее, подготовил решение, которое (IMHO) еще лучше и интересно.

Ответ 2

Вот один пример в С++ 11 (спасибо max66 comment) на основе max66 отличный ответ. Различия здесь:

  • нет дополнительного аргумента шаблона для Node (вместо этого, используя наследование базового класса и наследования конструктора)
  • требуемые аргументы получены с немного иным стилем, чем показано в вопросе
    • добавление перегрузок для квалифицированных функций-членов прост
    • ссылки не являются проблемой (насколько я могу судить, см. пример ниже печати 42)

http://coliru.stacked-crooked.com/a/53c23e1e9774490c

#include <iostream>

template<class... Ts> struct Types {};

template<class R, class C, class... Args>
constexpr Types<Args...> get_argtypes_of(R (C::*)(Args...)) {
    return Types<Args...>{};
}

template<class R, class C, class... Args>
constexpr Types<Args...> get_argtypes_of(R (C::*)(Args...) const) {
    return Types<Args...>{};
}

template<class T, class ConstructorArgs>
struct NodeImpl;

template<class T, class Arg0, class... Args>
struct NodeImpl<T, Types<Arg0, Args...>> {
  NodeImpl(Arg0 v0, Args...) {
    v0 = typename std::decay<Arg0>::type(42);
    (void)v0;
  }
};

template<class T>
struct Node
  : NodeImpl<T, decltype(get_argtypes_of(&T::process))>
{
  using ConstructorArgs = decltype(get_argtypes_of(&T::process));
  using NodeImpl<T, ConstructorArgs>::NodeImpl;
};

struct Foo {
    void process(int, char, unsigned) const {}
};

struct Bar {
    void process(double&) {}
};

int main() {
    Node<Foo> foo_node{4, 'c', 8u};

    double reftest = 2.0;
    Node<Bar> bar_node{reftest};
    std::cout << reftest << std::endl;
}

Ответ 3

Использование совершенной пересылки (live):

template<typename... Args>
Node(Args&&... args) {
    process(std::forward<Args>(args)...);
}

Ответ 4

Вот решение, использующее С++ 14. (Примечание: я тестировал его только в clang):

#include <string>
#include <utility>

struct Foo {
    void process(int, std::string);
};

template <typename T>
struct Input { };

template <std::size_t N, typename T, typename ...Types>
struct Extract_type {
    using type = typename Extract_type<N - 1, Types...>::type;
};

template <typename T, typename ...Types>
struct Extract_type<0, T, Types...> {
    using type = T;
};

template <typename T, std::size_t N, typename R, typename ...Args>
typename Extract_type<N, Args...>::type extract(R (T::*)(Args...));

template <typename T, typename R, typename ...Args>
std::integral_constant<std::size_t, sizeof...(Args)> num_args(R (T::*)(Args...));

template <typename T>
struct Node {
    template <typename ...Args>
    Node(Input<Args>&&... args) 
    : Node(std::make_index_sequence<decltype(num_args<T>(&T::process))::value>{ }, std::forward<Input<Args>>(args)...)
    {}

    template <std::size_t ...Indices>
    Node(std::index_sequence<Indices...>, Input<decltype(extract<T, Indices>(&T::process))>...) {}
};


int main() {
    Node<Foo> b{ Input<int>{ }, Input<std::string>{ } };
}

http://coliru.stacked-crooked.com/a/da7670f80a229931

Ответ 5

Как использовать приватное наследование и CRTP?

#include <tuple>
#include <iostream>

template <typename Method> struct method_traits;

template <typename T, typename Ret, typename... Args>
struct method_traits<Ret(T::*)(Args...)> {
public:
    using parameter_pack = std::tuple<Args...>;
};

template <typename Derived, typename Tuple> struct Base;

template <typename Derived, typename... Ts>
struct Base<Derived, std::tuple<Ts...>> {
    void execute_constructor(Ts&&... ts) { 
        Derived* d = static_cast<Derived*>(this);
        d->t.process(std::forward<Ts>(ts)...);
        d->num = sizeof...(Ts);
    }
    virtual ~Base() = default;
};

template <typename T, typename... Rest>
class Node : Base<Node<T, Rest...>, typename method_traits<decltype(&T::process)>::parameter_pack> {
    T t;
    int num;
public:
    using Base = Base<Node<T, Rest...>, typename method_traits<decltype(&T::process)>::parameter_pack>;
    friend Base;  // So that Base can do whatever it needs to Node<T, Rest...> data members.
    template <typename... Ts>
    Node (Ts&&... ts) {
        Base::execute_constructor(std::forward<Ts>(ts)...);
        std::cout << "num = " << num << '\n';
    }
};

struct foo {
    void process(int a, char c, bool b) {
        std::cout << "foo(" << a << ", " << c << ", " << std::boolalpha << b << ") carried out.\n";
    }   
};

int main() {
    Node<foo> n(5, 'a', true);
    std::cin.get();
}

Вывод:

foo(5, a, true) carried out.
num = 3