[英]How to pass around parameter packs in C++?
請考慮以下示例:
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
的構造函數上使用它?
顯然,您無法以這種方式保存類型列表
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;
現在您可以使用默認模板值和部分特化技巧定義節點
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);
}
- 編輯 -
正如Julius(以及OP本身)所指出的,此解決方案需要一個具有默認模板值的附加模板類型。
在這個簡化的情況下不是問題,但我可以想象無法添加此附加模板參數的情況(例如:如果Node
接收模板參數的可變參數列表)。
在這些情況下,Julius提出了一種使解決方案復雜化但允許避免Node
的附加模板參數的方法:添加模板基類,接收TArgs
參數,以及使用構造函數繼承。
即:定義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; };
朱利葉斯遵循這個想法,准備了一個解決方案 ,(恕我直言)更好,更有趣。
以下是基於max66的優秀答案的 C ++ 11中的一個示例(感謝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;
}
使用完美轉發( 直播 ):
template<typename... Args>
Node(Args&&... args) {
process(std::forward<Args>(args)...);
}
這是使用C ++ 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>{ } };
}
如何使用私有繼承和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...>'s 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
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.