我想在变量arity的C++中使用通用的zipWith函数.我有两个问题.首先是我无法确定传递给zipWith的函数指针的类型.它必须与传递给zipWith的向量数相同,并且必须分别接受对向量元素类型的引用.第二个是我不知道如何并行处理这些向量来构建一个参数列表,调用func(),并在最短的向量用完后保释.
template <typename R, typename T, typename... Vargs>
std::vector<R> zipWith (R func(???<what goes here>), std::vector<T> first, Vargs rest) {
???
}
在C#和Java中,可以使用一个或多个其他常量字符串创建常量字符串.我试图在C++中实现相同的结果(实际上,在C++ 0x中,具体而言),但是不知道我将使用什么语法来实现它,如果在C++中可以实现这样的话.这是一个说明我想要做的事情的例子:
#include <stdio.h>
const char array1[] = "Hello ";
const char array2[] = "world!\n";
const char array3[] = array1 + array2; // C++ doesn't like it when I try this
int main() {
printf(array3);
return 0;
}
有什么指针吗？(没有双关语.)
编辑:我需要能够将它应用于整数数组 - 而不仅仅是char数组.但是,在这两种情况下,待组合数组都是固定大小的并且是编译时常量.
我正在尝试围绕使用不透明数据类型的旧C-API创建C++便捷包装器.有一个特定的C函数,它使用格式字符串,以及使用C <stdarg.h>工具的可变数量的参数.作为我的包装器的一部分,我希望能够将任意数量的参数(包括C++对象)传递给此函数.但是,由于<stdarg.h>设施显然无法处理非POD数据,因此我创建了一个模板化转换函数,它将C++对象(如std::string)转换为POD等价物.
我认为整个事情使用C++ 0x可变参数模板是一个简单的练习,但是我很难弄清楚如何在将转换函数应用于每个参数时正确地展开参数包的方式编写此函数.
到目前为止我所拥有的是:
template <class T, class... Args>
void apply(OPAQUE* object, const char* fmt_string, T&& val, Args&&... args)
{
apply(object, fmt_string, Convert(val), args...);
}
template <class... Args>
void apply(OPAQUE* object, const char* fmt_string, Args&&... args)
{
C_API_Function_Call(object, fmt_string, args...);
}
当然,这不起作用,因为递归函数调用永远不会实际解包Args...,所以它只是递归直到堆栈溢出.我无法弄清楚如何解压缩参数,同时将当前参数传递给Convert函数,然后递归传递结果.
反正有没有这样做？
我试图用一个模板化的类来替换我的所有"获取/发布"RAII类(我现在每种资源都有一个).获取的一般形式是一些类型是Acquire(),一些是Acquire(p1),一些是Acquire(p1,p2)等.Release也是如此.但是,如果资源是使用参数获取的,则需要使用相同的参数释放它.
我想我可以使用可变参数模板,将参数存储在元组中.当然,我已经贬低了语法.有人可以帮忙吗？
#include <tuple>
template<class T, typename... Args>
class Raii
{
public:
Raii(T * s, Args&& ... a) : subect(s), arguments(a)
{
subject->Acquire(arguments);
}
~Raii()
{
subject->Release(arguments);
}
private:
T subject;
std::tuple<Args...> arguments;
};
class Framebuffer
{
public:
void Acquire() {}
void Release() {}
};
class Sampler
{
public:
void Acquire(int channel) {}
void Release(int channel) {}
};
class Buffer
{
public:
void Acquire(int target, int location) {}
void Release(int target, int location) {}
};
int main(void)
{
Framebuffer f; …由于我选择了一个误导性的问题标题,因此这个问题被完全复制了.这没错,但建议经常讨论一个问题,例如在这个问题中.由于内容是关于Stackoverflow上从未涉及的更具体的主题,我希望重新打开该问题.现在发生了这种情况,所以这就是问题所在.
我给了一个期望三个整数值作为参数的函数length(int x, int y, int z);.我无法修改此函数,例如接受任何单个参数的结构或元组.
在C++中有没有办法编写另一个函数,可以作为上面函数的单个参数,比如length(arguments());？
无论如何,该函数的返回类型arguments();似乎需要int, int, int.但据我所知,我无法在C++中定义和使用这样的函数.我知道我可以返回一个列表,一个元组,一个结构或一个类arguments().问题已经结束,因为有些人认为我会问这个问题.但困难的部分是传递元组,结构,或任何三个给定的整数参数.
这是可能的吗？如果是的话,这在C++中怎么可能？使用C++ 11的解决方案没问题.
template< typename ... Args >
class Message {
public:
Message( Args&& ... args ) {
mArgs = std::make_tuple( args ... );
}
std::tuple< Args ... > mArgs;
typedef std::function< void ( Args ... ) > HandlerType;
void Consume( HandlerType handler ) {
// handler( mArgs );
// How does one unpack this?
}
};
// Testing code
Message<int, int> msg(1, 2);
msg.Consume( [] ( int i, int j ) {
std::cout << i << ',' << j << '\n';
}); …我必须调用一个可变参数模板函数,它可以接受任意数量的参数.
template < class ... Args >
void f( Args&... args);
我希望编写一个小的包装器函数,以便我可以调用f包含在固定大小容器(如std :: array)中的相同类型的N个参数.
目标是写出类似的东西
std::array<int, 3> arr = {1,2,3};
wrapper(arr); // calls f(1,2,3);
我试图使用初始化列表的一些组合,std::forward但无济于事.有没有办法实现我想要的？
有办法:
1)删除索引处的项目:
// Removes item at index N, e.g. Remove<2, a, b, c, d> results in <a, b, d>
template<std::size_t N, typename ...Args>
struct Remove {
// ???
};
2)替换索引处的项目:
// Replaces item at index N with T, e.g. Replace<2, x, a, b, c, d> results in <a, b, x, d>
template<std::size_t N, typename T, typename ...Args>
struct Replace {
// ???
};
3)更换范围内的物品
// Replaces items in range [N1, N2] with T, e.g. ReplaceRange<2, 3, x, a, b, c, …c++ templates template-meta-programming variadic-templates c++11
在数据库库(soci)中,下面有一大块代码可以处理std::tuple<>一到十个参数.
静态类方法from_base(),to_base()用于1元组到10元组的参数.
guts基本上将每个n元组元素传入传入的流中.一切都是硬编码的.
如何将此代码转换为使用C++ 11的可变参数模板(参数没有限制)？ 实际上使用可变参数模板是次要的.我们真正想做的是用n-tuple参数的一般情况替换硬编码.
部分问题是,从技术上讲,只有一个参数,但该参数是一个n元组,所以我不能完全使用维基百科中的描述.什么是最好的方法？
#include "values.h"
#include "type-conversion-traits.h"
#include <tuple>
namespace soci
{
template <typename T0>
struct type_conversion<std::tuple<T0> >
{
typedef values base_type;
static void from_base(base_type const & in, indicator ind,
std::tuple<T0> & out)
{
in
>> std::get<0>(out);
}
static void to_base(std::tuple<T0> & in,
base_type & out, indicator & ind)
{
out
<< std::get<0>(in);
}
};
template <typename T0, typename T1>
struct type_conversion<std::tuple<T0, T1> …TBB的文档提供了这个例子中使用与parallel_for时lambda表达式,但不提供使用与lambda表达式的例子tbb::task::enqueue.
我正在寻找一个tbb::task::enqueue使用lambda表达式的简单示例.
关于如何使用元组的元素调用可变参数函数有很多问题.例如: 如何将元组扩展为可变参数模板函数的参数？ 我的问题有点不同:
我有一系列功能:
void f(int arg1);
void f(int arg1, int arg2);
...
我想要一个模板:
template<size_t Arity>
void call(std::vector<int> args) {
???
}
这称为适当f的args[0], args[1]...