Please take note of the updates at the end of this post.
Update: I have created a public project on GitHub for this library!
I would like to have a single template that once and for all takes care of pretty-printing all STL containers via operator<<. In pseudo code, I'm looking for something like this:
template<container C, class T, String delim = ", ", String open = "[", String close = "]">
std::ostream & operator<<(std::ostream & o, const C<T> …考虑具有可变参数模板参数的模板化函数的情况:
template<typename Tret, typename... T> Tret func(const T&... t);
现在,我有一个t价值元组.如何func()使用元组值作为参数调用？我已经阅读了bind()函数对象,call()函数,以及apply()不同的一些现在过时的文档中的函数.GNU GCC 4.4实现似乎call()在bind()类中有一个函数,但是关于这个主题的文档很少.
有些人建议使用手写的递归黑客,但可变参数模板参数的真正价值在于能够在上述情况下使用它们.
有没有人有解决方案,或提示在哪里阅读它？
我做了以下元组:
我想知道如何迭代它？有tupl_size(),但阅读文档,我没有得到如何利用它.我也搜索了SO,但问题似乎就在附近Boost::tuple.
auto some = make_tuple("I am good", 255, 2.1);
我使用 SO问题的答案"迭代元组"来编写一个重载方法<<.这个方法经过测试,似乎可以g++ 4.7在Debian squeeze上正常工作.
然而,这种方法有点迂回,因为它似乎<<无法明确实例化(我在这里发现了一篇关于它的帖子
).因此,一个人被迫定义一个字符串方法,然后调用它.我有一个类似的矢量方法,更直接.有没有人建议如何消除创建字符串方法的额外步骤,使用相同的方法,或其他？提前致谢.
#include <tuple>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
using std::ostream;
using std::cout;
using std::endl;
using std::vector;
using std::string;
// Print vector<T>.
template<typename T> ostream& operator <<(ostream& out, const vector<T> & vec)
{
unsigned int i;
out << "[";
for(i=0; i<vec.size(); i++)
{
out << vec[i];
if(i < vec.size() - 1)
out << ", ";
}
out << "]";
return out;
}
////////////////////////////////////////////////////////////////
// …所以,如果我有这样的事情
template<typename... Args >
class tuple_class
{
public:
std::tuple<Args...> tup;
/*I left out the other functions */
};
我想重载运算符<<,以便它在类上调用时递归打印元组.
恩.
auto a = tuple_class(1, 2 ,3);
std::cout << a << endl;
希望打印'123'
我见过了元组打印机的其他例子,但我不能在没有麻烦的情况下将它应用到我的班级
我想我应该从这样的成员函数开始
template<typename... Args>
friend std::ostream& operator<<(std::ostream& os, const my_tuple<Args...> &m);
然后是课外的实际功能
template<typename... Args>
std::ostream& operator<<(std::ostream& os, const my_tuple<Args...> &m)
{
os << "SOMETHING" << std::endl;
return os;
}
当我在班上调用<<运算符时,这实际上有效.但我不知道如何让它实际打印元组.
任何帮助,将不胜感激
// problem.cpp:
#include <string>
template<typename T> void func(const T & v);
int main() {
int i;
float f;
char * cp;
char ca[4];
func(i);
func(f);
func(cp);
func(std::string("std::string"));
func(ca);
func("string_literal");
return 0;
}
// problem2.cpp
#include <string>
template<typename T> void func(const T & v);
// undefined reference to `void func<int>(int const&)'
template<> void func<int>(const int & v) { }
// undefined reference to `void func<float>(float const&)'
template<> void func<float>(const float & v) { }
// undefined reference to `void func<char*>(char* const&)' …我试图弄清楚如何使用C ++ 17折叠表达式仅折叠可变参数模板包的一部分。假设我想创建一个编译时的“分隔字符串”，例如"str1_str2_str3_....."
使用这样的代码可以很容易地做到这一点（仅作为示例）：
std::string result;
template<class... Strings>
ConcatString(Strings&... strs)
{
(ConcatString(strs), ...);
}
template <class String>
void ConcatString(String& str)
{
result += str + "_"
}
然后我们可以像这样执行它
std::string s1 = "s1", s2 = "s2", s3 = "s3";
ConcatString(s1, s2, s3);
// result == "s1_s2_s3_"
如您所见，最后一个定界符存在问题。没有运行时检查，有什么办法可以避免此问题？我可以想象的一种解决方案是仅折叠（N-1）个arg，并“手动”连接最后一个。
在数据库库(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> …是否有一种很好的方法可以将函数的参数转发f给g类似情境中的函数
template<typename... T>
void g(T && ... x);
template<typename... T>
void f(T && ... x)
{
g(x..., x...);
}
在下一个代码中x可以移动两次
template<typename... T>
void f(T && ... x)
{
g(std::forward<T>(x)..., std::forward<T>(x)...);
}
在下一个代码std::forward<T>(x)...之前可以进行评估x...
template<typename... T>
void f(T && ... x)
{
g(x..., std::forward<T>(x)...);
}
我希望使用运算符 [] 中传递的表达式。我认为使用变量模板参数可以解决问题，但我错了......在 c++11 中是否有一种方法可以做到这一点？
class object {
private:
public:
void values() { std::cout << "finished" << std::endl; }
template <typename T, typename... Type> void values(T arg, Type... args) {
std::cout << arg << " " << std::endl;
values(args...);
}
template<typename... Type> void operator[](Type... args) {
values(args...);
}
};
int main(void) {
object o1 = object();
o1.values(1, 6.2, true, "hello"); // Works fine.
o1[1, 6.2, true]; // Only the last value gets printed eg. true
return 0;
}
更广泛的目标是我被要求为此制定一个工作语法
let …