我想要一个非常友好的ToString功能,包括许多类型std::tuple.功能是这样的:
template <typename T>
inline std::string ToString(const T &t) {
std::stringstream ss;
ss << t;
return ss.str();
}
template <typename... Args>
inline std::string ToString(const std::tuple<Args...> &t) {
std::stringstream ss;
for (int i = 0; i < t.size(); i++) {
ss << ToString(std::get<i>(t)) << " ";
}
return ss.str();
}
第二部分是语法错误,如何用c ++ 11模板实现它？
而且,如何实现FromString这样的:
template <typename T>
inline T FromString(const std::string &s) {
std::stringstream ss(s);
T t;
ss >> t;
return t;
}
template <typname... …问题很简单,为什么这段代码不起作用:
#include <tuple>
int main( int argc, char* argv[]) {
const int a,b = std::tie(std::make_pair(1,2));
return EXIT_SUCCESS;
}
g ++给了我这个错误:
./test.cpp:在函数'int main(int,char**)'中:./ test.cpp:4:13:error:uninitialized const'a'[-fpermissive] const int a,b = std ::领带(标准:: make_pair(1,2)); ^ ./test.cpp:4:42:
error:无法将类型为'std :: pair&'的非const左值引用绑定到类型为'std :: pair'的rvalue
const int a,b = std :: tie(std :: make_pair(1,2));
使用这种模式(const或非const),我无法通过值获得任何类似元组的返回.这是一个更好的方式来做我想在这里实现的目标吗？
我有一个功能模板:
template <typename... Us>
void set_args(const void* p, Us&... args);
我有一个std::tuple我要打开的东西args.我目前的解决方案是
template <typename... Us, std::size_t... Idx>
void set_args_2(
const void* p, std::tuple<Us...>& args, std::index_sequence<Idx...>) {
set_args(p, std::get<Idx>(args)...);
}
template <typename... Us>
void func(std::tuple<Us...>& args, ...) {
...
set_args_2(p, args, std::index_sequence_for<Us...>{});
...
}
注意set_args_2()纯粹的人工Idx解压缩元组.有没有办法将元组解压缩到位func(),这样set_args()可以直接调用？
我的问题是关于参数包和相关元组.如何创建与参数包相同大小的元组,但是使用单个独立类型？
template <class... T>
class Thing {
public:
// some struct that was found helpful for any Type used as parameter
struct HelperData{
int a;
int b;
};
[...]
private:
// the tuple used as normally, my initial reason to use parameter pack
std::tuple<T...> m_tuple;
// now I want a tuple of N values of type HelperData, where N is sizeof...(T)
std::tuple<HelperData...sizeof...(T)> m_helperData; //???
};
回顾性评论:
这个问题可能在技术上有效并且有很好的答案.但是潜在的概念提出了越来越多的问题(如何一次迭代多个容器等).使用C++ 14或更新版本可能是正确的选择,但是,我发现使用C++ 11时,当我解决问题时,事情会变得非常容易:
我有一个类型/对象列表,由参数包表示.这将主元组定义为类成员.现在我想要为这些类型/对象中的每一个存储在附加元组中的附加信息.不要那样做.这个结构可以(几乎)总是被单个元组替换,包含例如具有所有元素的结构,否则这些元素分布在多个元组中.
我用 std::make_tuple 函数制作大元组。
像这样的东西
template <class ...T>
QCborArray array(const T&... args) {
return {args...};
}
但用元组而不是参数包
我正在实现一个有限状态机，其中所有可能的状态都存储在std::tuple.
这是我面临的问题的最小编译示例及其 godbolt 链接https://godbolt.org/z/7ToKc3T3W：
#include <tuple>
#include <stdio.h>
struct state1 {};
struct state2 {};
struct state3 {};
struct state4 {};
std::tuple<state1, state2, state3, state4> states;
template<size_t Index>
void transit_to()
{
auto state = std::get<Index>(states);
//Do some other actions over state....
}
void transit_to(size_t index)
{
if (index == 0) return transit_to<0>();
if (index == 1) return transit_to<1>();
if (index == 2) return transit_to<2>();
if (index == 3) return transit_to<3>();
}
int main()
{
for(int i=0; i<=3; …原始上下文：\n我试图将 (object,expected_value_of_some_property) 的元组传递给测试函数
\n我创建了一个简单的类来重现我面临的错误：
\ntemplate <typename T>\nclass Vector\n{\nprivate:\n size_t m_size;\n std::unique_ptr<std::vector<int>> m_vector;\n\npublic:\n Vector();\n Vector(const Vector<int>&);\n ~Vector() = default;\n\n void push_back(T);\n T get(int) const;\n size_t size() const;\n};\n\ntemplate <typename T>\nVector<T>::Vector()\n:m_size(0), \nm_vector(new std::vector<T>)\n{}\n\ntemplate <typename T>\nVector<T>::Vector(const Vector<int>& v)\n:m_size(v.size()), \nm_vector(new std::vector<T>)\n{\n for (size_t i = 0; i < v.size(); i++)\n {\n this->push_back(v.get(i));\n }\n}\n\ntemplate <typename T>\nvoid Vector<T>::push_back(T value)\n{\n m_vector->push_back(value);\n m_size ++;\n}\n\ntemplate <typename T> \nT Vector<T>::get(int index) const\n{\n return m_vector->operator[](index);\n}\n\ntemplate <typename T> \nsize_t Vector<T>::size() const\n{\n return m_size;\n}\n当尝试在测试代码中生成 Vector 对象的元组和 int 时，会触发该错误：
\nint …这不是秘密,std::get<i>(tuple)让许多程序员感到恼火.
而不是它,我想要使用类似的东西tuple[i].
所以我试着模拟它.
#include <iostream>
#include <type_traits>
#include <tuple>
template < int > struct index{};
template< char ... >
struct combine;
template<> struct combine<> : std::integral_constant< int , 0>{};
constexpr int ten(size_t p)noexcept
{
return p == 0 ? 1 : 10 * ten(p-1);
}
template< char c, char ... t>
struct combine<c, t...> : std::integral_constant< int, (c - '0')*ten(sizeof...(t)) + combine<t...>::value >
{ static_assert(c >= '0' && c <= '9', "only 0..9 digits are allowed"); …我有一个带有字符串键的无序映射和一个包含三个字符串和一个int的元组.如何访问单个元组来设置它们.
鉴于:
std::unordered_map<string,std::tuple<string, string, string,int>> foo_data_by_username;
如何设置say的单个元组值 foo_data_by_username[some_user];
我正在尝试在C ++ 11中定义一个元组向量，如下所示：
#include <iostream>
#include <string>
#include <vector>
#include <tuple>
typedef unsigned char uchar;
typedef std::tuple<uchar, std::string, uchar, float> fruitInfoTuple;
const std::vector<fruitInfoTuple> jointsInfo{
{ 0, "mango", 100, -6.01},
{10, "apple", 144, 6.25},
{12, "orange", 159, 2.59},
{33, "banana", 144, -28.96},
{ 4, "grapes", 128, 3.79},
};
我在启用C ++ 11标志的情况下编译程序。但是，它显示出并发症错误，如下所示：
ravi@lab:~/Desktop/a$ g++ -std=c++11 learn.cpp
learn.cpp:14:1: error: converting to ‘std::tuple<unsigned char, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned char, float>’ from initializer list would use explicit constructor ‘constexpr std::tuple< <template-parameter-1-1> >::tuple(_UElements&& ...) [with …