C++ c++；：将向量转换为元组

如何将std:：vector转换为std:：tuple？ 我有

我怎样才能得到这个tp？ 如果cnt足够大，我就不能手动编写这个tp

  std::vector<
  ConvConnection<
  decltype(inputLayer),
  decltype(*C1[0]),
  decltype(*Conn1Opt[0]),
  RandomInitialization<arma::mat>,
  arma::mat
  >* > Conn1(6);

  for (size_t i = 0; i < 6; ++i) {
    Conn1.push_back(new  ConvConnection<
                    decltype(inputLayer),
                    decltype(*C1[0]),
                    decltype(*Conn1Opt[0]),
                    RandomInitialization<arma::mat>,
                    arma::mat
                    >(inputLayer, *C1[i], *Conn1Opt[i], 5, 5));
  }

std:：vector< 连接< decltype（输入层）， decltype（*C1[0]）， decltype（*Conn1Opt[0]）， 随机初始化， 阿玛：马特 >*>Conn1（6）； 对于（尺寸i=0；i<6；++i）{ 连接1.推回（新连接< decltype（输入层）， decltype（*C1[0]）， decltype（*Conn1Opt[0]）， 随机初始化， 阿玛：马特 >（输入层，*C1[i]，*Conn1Opt[i]，5,5））； }

---

这是代码。这里只有6个，但我还需要一些大小超过100的向量。我需要把这个向量转换成元组。

你就是不能。因为向量大小在运行时是已知的，但是

tuple

type（包括其大小）必须在编译时已知

通常，无法将

向量

转换为

元组

。但是，如果您所要做的只是使某些

N

的元组

成为一个常量表达式，那么使用索引序列技巧是可行的：

template <typename F, size_t... Is>
auto gen_tuple_impl(F func, std::index_sequence<Is...> ) {
    return std::make_tuple(func(Is)...);
}

template <size_t N, typename F>
auto gen_tuple(F func) {
    return gen_tuple_impl(func, std::make_index_sequence<N>{} );
}

模板
自动生成元组（F func，std:：索引序列）{
返回std:：make_tuple（func（Is）…）；
}
模板
自动生成元组（F func）{
返回gen_tuple_impl（func，std:：make_index_sequence{}）；
}

我们可以这样使用：

// make a tuple of the first 10 squares: 0, 1, 4, ..., 81
auto squares = gen_tuple<10>([](size_t i){ return i*i;});

//将前10个正方形组成一个元组：0，1，4，…，81
自动平方=gen_tuple（[]（size_t i）{return i*i；}）；

对于您的特定用例，这将是：

auto connections = gen_tuple<6>([&](size_t i) {
    return new ConvConnection<
                decltype(inputLayer),
                decltype(*C1[0]),
                decltype(*Conn1Opt[0]),
                RandomInitialization<arma::mat>,
                arma::mat
                >(inputLayer, *C1[i], *Conn1Opt[i], 5, 5);
});

auto connections=gen\u tuple（[&]（大小）{
返回新连接<
decltype（输入层），
decltype（*C1[0]），
decltype（*Conn1Opt[0]），
随机初始化，
阿玛：马特
>（输入层，*C1[i]，*Conn1Opt[i]，5,5）；
});

如果你有C++14，你可以这样做：

template <typename T, std::size_t... Indices>
auto vectorToTupleHelper(const std::vector<T>& v, std::index_sequence<Indices...>) {
  return std::make_tuple(v[Indices]...);
}

template <std::size_t N, typename T>
auto vectorToTuple(const std::vector<T>& v) {
  assert(v.size() >= N);
  return vectorToTupleHelper(v, std::make_index_sequence<N>());
}

模板
auto VectorTupleHelper（常量std:：vector&v，std:：index_序列）{
返回std:：make_tuple（v[索引]…）；
}
模板
自动矢量耦合（const std:：vector&v）{
断言（v.size（）>=N）；
返回vectorTupleHelper（v，std:：make_index_sequence（））；
}

---

由于自动扣除，这是确定的。在C++11中，在没有自动推断的情况下，必须使用尾部

decltype

编写返回类型。您还必须实现自己的

索引\u序列

，那么如何获得“大”元组？我想得到自动的tp=std:：tie（T1，T2，T3，…TN）假设N足够大，我必须生成T1。。。TN动态。假设在我编写代码时N是固定的，“大”元组是什么？如果手动编写它太大或太麻烦，请编写另一个程序生成它。如果要在运行时确定元组的大小，则不能。为什么需要元组？

std:：array

会不会起作用？一个离题的挑剔：你真的应该有更好的变量/类名。没有理由

cnt

不能被写为

count

。什么是连接<代码>连接1端口？在2015年，你的源文件仍然可以放在你的硬盘上，里面还有一些额外的字符，其他查看你代码的开发人员稍后会感谢你：）谢谢。但我需要tuple，其中每个Ti是一个类。我用这个来建立一个神经元网络。因为当前的NN框架使用元组，但现在我的网络太大了，我无法手动编写它。似乎我必须更改框架或使用其他程序生成框架。@HurricaneTong您也可以使用类来完成此操作。只需将

make\u tuple（Is…

替换为

make\u tuple（new T（Is…）

。我更新问题并给出我的真实代码。元组中的每个类都有不同的构造参数。JARAXUSTSUN更新了我的答案，允许你可以通过一个函数。我知道这是一个相当古老的问题，但是如何在没有自动推理的情况下编写模板参数，但是C++ 17支持？恐怕我不知道-我没有跟上C++的PAST14。

auto connections = gen_tuple<6>([&](size_t i) {
    return new ConvConnection<
                decltype(inputLayer),
                decltype(*C1[0]),
                decltype(*Conn1Opt[0]),
                RandomInitialization<arma::mat>,
                arma::mat
                >(inputLayer, *C1[i], *Conn1Opt[i], 5, 5);
});

template <typename T, std::size_t... Indices>
auto vectorToTupleHelper(const std::vector<T>& v, std::index_sequence<Indices...>) {
  return std::make_tuple(v[Indices]...);
}

template <std::size_t N, typename T>
auto vectorToTuple(const std::vector<T>& v) {
  assert(v.size() >= N);
  return vectorToTupleHelper(v, std::make_index_sequence<N>());
}