我正在尝试存储std::tuple不同数量的值,这些值稍后将用作调用与存储类型匹配的函数指针的参数.
我创建了一个简化的示例,显示了我正在努力解决的问题:
#include <iostream>
#include <tuple>
void f(int a, double b, void* c) {
std::cout << a << ":" << b << ":" << c << std::endl;
}
template <typename ...Args>
struct save_it_for_later {
std::tuple<Args...> params;
void (*func)(Args...);
void delayed_dispatch() {
// How can I "unpack" params to call func?
func(std::get<0>(params), std::get<1>(params), std::get<2>(params));
// But I *really* don't want to write 20 versions of dispatch so I'd rather
// write something like:
func(params...); // Not legal
}
}; …c++ function-pointers variadic-templates c++11 iterable-unpacking
考虑具有可变参数模板参数的模板化函数的情况:
template<typename Tret, typename... T> Tret func(const T&... t);
现在,我有一个t价值元组.如何func()使用元组值作为参数调用？我已经阅读了bind()函数对象,call()函数,以及apply()不同的一些现在过时的文档中的函数.GNU GCC 4.4实现似乎call()在bind()类中有一个函数,但是关于这个主题的文档很少.
有些人建议使用手写的递归黑客,但可变参数模板参数的真正价值在于能够在上述情况下使用它们.
有没有人有解决方案,或提示在哪里阅读它？
所以我有一些类型X:
typedef ... X;
和模板功能f:
class <typename T>
void f(X& x_out, const T& arg_in);
然后是一个功能g:
void g(const X* x_array, size_t x_array_size);
我需要编写一个variadic模板函数h来执行此操作:
template<typename... Args>
void h(Args... args)
{
constexpr size_t nargs = sizeof...(args); // get number of args
X x_array[nargs]; // create X array of that size
for (int i = 0; i < nargs; i++) // foreach arg
f(x_array[i], args[i]); // call f (doesn't work)
g(x_array, nargs); // call g with …目前我在尝试存储参数包时遇到问题,这是设计的示例代码:
template<typename Func, typename... Args>
void handleFunc(Func func, Args&&... args) {
struct nest {
Func nestFunc;
Args... nestArgs; // I DONT KNOW WHAT TO DO HERE
void setup(Func func, Args... args) {
nestFunc = func;
nestArgs = (args)...; // SO I CAN SET IT HERE
}
// Later I will forward this and run the function with its arguments
unsigned process() {
nestFunc(std::forward<Args>(nestArgs)...); // USE IT HERE
return 0;
}
};
nest* myNest;
myNest->setup(func, (args)...);
}
这是问题所涉及的所有内容的示例,我需要存储参数以便稍后在我的nest结构中调用.此外,如果你有一个解决方案来存储它,但设置它与我的不同,也请让我知道这一点.谢谢.
所以我试图弄清楚它是如何工作的:C++ 11:我可以从多个args转到元组,但是我可以从元组转到多个args吗？
我不明白的黑魔法是这段代码片段:
f(std::get<N>(std::forward<Tuple>(t))...)
这f是我不明白的内心表达.
我理解表达式以某种方式解压缩/扩展内部t的参数列表.但有人可以解释如何做到这一点？当我看到std::get(http://en.cppreference.com/w/cpp/utility/tuple/get)的定义时,我看不出有多N适合......？据我所知,N是一个整数序列.
根据我可以观察,我假设的形式表达E<X>...,其中X是类型的序列X1.X2,... Xn,表达式将扩展为E<X1>, E<X2> ... E<Xn>.这是怎么回事？
编辑:在这种情况下,N不是类型序列,而是整数.但我猜这种语言结构适用于类型和值.
我有一系列类,其方法具有以下签名:
double compute(list<T> pars)
此方法使用通过接收的参数执行计算pars.对于每种compute(list)方法,我有另一种方法,compute(x1, x2, ..., xn)即实现实际计算的方法.因此,compute(pars)应该做一些如:
double compute(list<T> pars)
{
T x1 = list.pop_back();
T x2 = list.pop_back();
// .. so on until last parameter xn
T xn = list.pop_back();
return compute(x1, x2, .., xn); // here the real implementation is called
}
这种模式重复多次,唯一可以改变的是pars列表的大小,当然还有实现compute(x1, x1, ..).
我想找到一种方法来"碾压"这个重复的过程; 具体来说,提取pars列表中的参数并构建调用compute(x1, x2, .., xn).我一直在尝试做一些宏观技巧而没有成功.
我的问题是,它是否存在某种基于元编程的方式,它允许我实现compute(list<T> pars)一次并简单地重用它以便执行调用compute(x1, x2, ..., xn)
编辑:这是另一个的签名compute(x1, …