Eloquent 需要对 std::tuple（即 std::get<E>）进行非常量索引访问的解决方案

Question

tl;dr 是否有 任何简单的方法 将 std::get 与非常量索引一起使用？

我知道这个问题已经被问过很多次了，但是 none 提出的解决方案似乎特别简单，eloquent，或者适合我的情况。

我正在寻找的是：使用 std::get<E> 的无痛方式，其中 E 是任何表达式，以便 return a T& 到 a T 已知存在于 std::tuple<T>.

中（即，对于范围异常是安全的，因此绕过了安全范围 std::get）

问题似乎是编译器需要知道 std::get 的 return 的类型，但我将手动输入数据及其类型，不需要确定类型。（也许 auto 可以用在什么地方？）

我想这样做的原因可以通过以下片段来解释。我正在尝试创建一个数据容器 class，您可以使用初始化列表来填充它。

要点：用于允许元组的模拟初始化程序列表。

template<class... T>
class Point {
public:
    std::tuple<T...> get() const { return data; }
    Point(T... t) {
        data = std::tuple<T...>(t...);
    }
private:
    std::tuple<T...> data;
};

数据：设计用于在 std::vector<T> 的 std::tuple 中保存动态数据量，其中 T 是一组用户定义类型中的每一个.

template<typename... T>
class Data {
public:
    Data(std::initializer_list<Point<T...>> data = {{}})
        : columns(sizeof...(T))
    {
        // ???
    }
private:
    byte columns;
    std::tuple<std::vector<T>...> datas;
};

结合起来，这应该允许这种简单的格式用于快速数据输入（或未来来自外部源的数据流）：
```
int main() {
    Data<char, int, float> {
        { 'A', 1, 3.14 } ,
        { 'B', 2, 6.28 }
    };

    return 0;
}
```

这些将在以后移植到一个充满有用扩展的库中，这些扩展可以使非程序员轻松输入数据和公式而无需大惊小怪的方式处理数据。公式的一半有效，但由于 std::get:

的限制，我在这一半上仍然遇到问题

for (auto d : data) {
    for (int i = 0; i < columns; ++i) {
        std::get<i>(datas).push_back(std::get<i>(data));
        // doesn't work; std::get<N> requires const N to know return type to use push_back
    }
}

我觉得这真的很令人沮丧，因为大多数人都是这样。由于多种类型，我无法将 datas 替换为 std::arrays 或 std::vectors；我想避免使用 boost 尽管 boost::any； switch (column) { case 0: std::get<0>(...)... } 可用于模仿动态 std::get，但如果我不能为每个可能的 n 列手动输入一个案例；仅仅为了这个小目的而对新的容器类型进行元编程的努力似乎不必要地过于复杂；似乎没有其他快速修复解决方案适合这些特定情况。

Answer 1

template<std::size_t I>
using index_t=std::integral_constant<std::size_t,I>;

template<std::size_t...Is, class F>
void for_each_from_indexes( std::index_sequence<Is...>, F&& f ){
  using discard=int[];
  (void)discard{0,(void(
    f(index_t<Is>{})
  ),0)...};
}
template<std::size_t N, class F>
void for_each_index( F&& f ){
  for_each_from_indexes( std::make_index_sequence<N>{}, std::forward<F>(f) );
}

现在我们可以在编译时使用一组索引调用 lambda。

template<class...Ts>
void add_data(std::tuple<Ts...> const& data){
  for_each_index<sizeof...(Ts)>([&](auto i){
    std::get<i>(datas).push_back(std::get<i>(data));
  });
}

i转索引不是运行时间，而是编译时间，这里

需要 C++14，但它是 2016。

可能有错别字。

Answer 2

tl;dr is there any easy way to use std::get with a non-const index?

不，因为根本没有一种方法可以将它与非常量索引一起使用。既不难也不好用。

但是你可以让你的构造函数像

Data(std::initializer_list<Point<T...>> data)
{
  for (auto&& d : data)
  {
    tup_to_vectup(std::make_index_sequence<sizeof...(T)>{},
      datas, d.data);
  }
}

有这样的小帮手

template<std::size_t ... I, class VecTup, class Tup>
void tup_to_vectup(std::index_sequence<I...>, VecTup&& vt, Tup&& t)
{
  int a[] = {
    0, (std::get<I>(vt).push_back(std::get<I>(t)), 0)...
  };
  (void)a;
}

因为这里实际上不需要非常量索引。您的 class 模板参数 ...T 在编译时确定索引。您只需要将它们转换为索引序列并使用它来迭代您的元组。

Eloquent 需要对 std::tuple（即 std::get<E>）进行非常量索引访问的解决方案

Eloquent solution to needing non-const indexed access of a std::tuple (i.e. std::get<E>)

c++

tuples

variadic