C++ C++；标准：：获取<；变量>；失败

如何使用std:：get将变量索引到元组中？我有以下代码：

#include <iostream>
#include <tuple>
using namespace std;

int main() {
  tuple<int, int> data(5, 10);
  for (int i=0; i<2; i++) {
    cout << "#" << i+1 << ":" << get<i>(data) << endl;
  }
  return 0;
}

#包括
#包括
使用名称空间std；
int main（）{
元组数据（5,10）；
对于（int i=0；i
如何使用std:：get将变量索引到元组中

您不知道，
std:：get
参数值必须在编译时已知

你知道怎么做吗

是的，使用合适的类型：

int main() {
  std::array<int, 2> data{ 5, 10 };
  for (int i=0; i<2; i++) {
    cout << "#" << i+1 << ":" << data[i] << endl;
  }
  return 0;
}

intmain（）{
std：：数组数据{5，10}；
对于（int i=0；i
如何使用std:：get将变量索引到元组中

您不知道，
std:：get
参数值必须在编译时已知

你知道怎么做吗

是的，使用合适的类型：

int main() {
  std::array<int, 2> data{ 5, 10 };
  for (int i=0; i<2; i++) {
    cout << "#" << i+1 << ":" << data[i] << endl;
  }
  return 0;
}

intmain（）{
std：：数组数据{5，10}；
对于（int i=0；i
你知道怎么做吗

选择1
使用编译时常量访问
std:：tuple

cout << "#" << 1 << ":" << get<0>(data) << endl;
cout << "#" << 2 << ":" << get<1>(data) << endl;

cout
你知道怎么做吗

选择1
使用编译时常量访问
std:：tuple

cout << "#" << 1 << ":" << get<0>(data) << endl;
cout << "#" << 2 << ":" << get<1>(data) << endl;

cout您应该采用的可能答案是只使用数组、向量或其他类型的索引容器


如果元组元素不是同构类型，并且您确实需要解决这个问题，那么这就有点复杂了。这是因为类型需要在编译时知道。因此，您认为可以做的事情是使用数组、向量或其他类型的索引contai内尔


如果元组元素不是同构类型，并且您确实需要对这种情况的答案，那么就有点复杂了。这是因为类型需要在编译时知道。所以您认为可以在哪里执行
std:：cout
#include
模板
自动索引结束（标准：：索引顺序）{
return[]（自动和&f）->decltype（自动）{
返回decltype（f）（f）（std：：积分常数{}；
};
}
模板
自动索引（std:：integral_常量={}）{
返回索引_over（std:：make_index_sequence{}）；
}
模板
自动前置器（F&&F）{
返回[f=std:：forward（f）]（自动和参数）可变{
（void（），…，void（f（decltype（args）（args）））；
};
}
模板
自动计数（标准：：积分常数={}）{
返回[]（自动（&f）{
索引_upto（）（foreacher（decltype（f）（f））；
};
}

您只需执行以下操作：

#include <iostream>
#include <tuple>

int main() {
  std::tuple<int, int> data(5, 10);
  count_upto<2>()([&](auto I){
    std::cout << "#" << (I+1) << ":" << std::get<I>(data) << "\n";
  });
}

#包括
#包括
int main（）{
std：：元组数据（5,10）；
计数上限（）（[&]（自动I）{
std:：cout
#包括
模板
自动索引结束（标准：：索引顺序）{
return[]（自动和&f）->decltype（自动）{
返回decltype（f）（f）（std：：积分常数{}；
};
}
模板
自动索引（std:：integral_常量={}）{
返回索引_over（std:：make_index_sequence{}）；
}
模板
自动前置器（F&&F）{
返回[f=std:：forward（f）]（自动和参数）可变{
（void（），…，void（f（decltype（args）（args）））；
};
}
模板
自动计数（标准：：积分常数={}）{
返回[]（自动（&f）{
索引_upto（）（foreacher（decltype（f）（f））；
};
}

您只需执行以下操作：

#include <iostream>
#include <tuple>

int main() {
  std::tuple<int, int> data(5, 10);
  count_upto<2>()([&](auto I){
    std::cout << "#" << (I+1) << ":" << std::get<I>(data) << "\n";
  });
}

#包括
#包括
int main（）{
std：：元组数据（5,10）；
计数上限（）（[&]（自动I）{
std:：cout简单的答案是tuple是错误的工具；您正在查找数组。请注意，tuple中的每个元素都可以有不同的类型，这意味着编译器甚至不知道哪个
运算符
std:：get
的索引是模板参数，必须在编译时知道。重新打开，因为另一个问题是问了一个稍有不同的问题，答案不适用于这个问题。这些问题是相关的，但差异很大，我认为这个问题应该得到一个正确的答案。请注意，您可以使用运行时提供的值创建一个递归模板函数，该函数可以应用
std:：get
，但除非
std:：tuple
类型u为每个元素设置完全相同的类型，您必须处理元组中任何类型的复杂性，当然，这是可以做到的。例如，让函数返回一个
boost:：any
对象，或者将值传递给一个具有重载来处理任何类型的functor/visitor对象。@cdho好吧，假设元组中的所有元素都有相同的类型（在我的例子中是这样的），您能详细说明一下您的解决方案吗？简单的回答是，tuple是错误的工具；您正在寻找数组。请注意，tuple中的每个元素都可以有不同的类型，这意味着编译器甚至不知道哪个
运算符
std:：get
的索引是模板参数，必须在编译时知道。Re开始是因为另一个问题提出了一个稍微不同的问题，答案不适用于这个问题。这些问题相互关联，但差异很大，我认为这一个问题应该得到正确的答案。请注意，您可以使用运行时提供的值创建一个递归模板函数，该函数可以应用
std:：get
，但除非
std:：tuple
类型对每个元素使用完全相同的类型，您必须处理复杂性，您必须能够处理tuple中的任何类型——当然，这是可以做到的。例如，让函数返回
boost:：any
对象，或者将值传递给具有重载的functor/visitor对象s来处理任何类型。@cdhowie好的，假设元组中的所有元素都具有相同的类型（在我的例子中是这样的），你能详细说明你的解决方案吗？我在问题中添加了一条注释，
array
对我来说不是一个选项。然后使用
std:：vector
，相信我，你不需要元组的解决方案，它会很长而且很复杂。我在问题中添加了一条注释，
array
对我来说不是一个选项。然后使用
std:：vector
，bel请相信我，您不需要元组的解决方案，它将是漫长而复杂的
#include <utility>

template<std::size_t...Is>
auto index_over( std::index_sequence<Is...> ) {
  return [](auto&& f)->decltype(auto){
    return decltype(f)(f)( std::integral_constant<std::size_t, Is>{}... );
  };
}
template<std::size_t N>
auto index_upto( std::integral_constant<std::size_t, N> ={} ) {
  return index_over( std::make_index_sequence<N>{} );
}
template<class F>
auto foreacher( F&& f ) {
  return [f=std::forward<F>(f)](auto&&...args)mutable {
    (void(), ..., void(f(decltype(args)(args))));
  };
}
template<std::size_t N>
auto count_upto( std::integral_constant<std::size_t, N> ={} ) {
  return [](auto&& f){
    index_upto<N>()(foreacher(decltype(f)(f)));
  };
}

#include <iostream>
#include <tuple>

int main() {
  std::tuple<int, int> data(5, 10);
  count_upto<2>()([&](auto I){
    std::cout << "#" << (I+1) << ":" << std::get<I>(data) << "\n";
  });
}