C++ 为元组实现创建索引序列

假设我想自己实现一些类似于

std:：tuple

的东西，只是一些基本的东西。我想先显示失败的尝试

#include <utility>
#include <iostream>

template <std::size_t I>
struct tuple_index_leaf {
    using Index = std::integral_constant<std::size_t, I>;
    std::size_t i = Index::value;
};

template <std::size_t... Is>
struct tuple_index : tuple_index_leaf<Is>...
{};

template <std::size_t I, std::size_t... Is>
constexpr auto get_index(tuple_index<Is...> const &i) {
    return static_cast<const tuple_index_leaf<I>*>(&i)->i;
}

template <std::size_t I, typename T>
struct tuple_leaf : tuple_index_leaf<I> {
    T elem;
};

template<typename... Ts>
struct tuple : tuple_leaf<sizeof...(Ts), Ts>... {

};

template <std::size_t I, typename... Ts>
auto& get(tuple<Ts...> &t) {
    return static_cast<tuple_leaf<I, float>*>(&t)->elem;
}

int main() {
    tuple_index<0, 1, 2> ti;
    std::cout << get_index<0>(ti) << "\n";
    tuple<int, float> t;
    get<2>(t) = 3.14;
} 

#包括
#包括
模板
结构元组索引叶{
使用Index=std：：积分常数；
std:：size\u t i=索引：：值；
};
模板
结构元组索引：元组索引叶。。。
{};
模板
constexpr自动获取索引（元组索引const&i）{
返回静态_cast（&i）->i；
}
模板
结构元组\叶：元组\索引\叶{
元素；
};
模板
结构元组：元组\叶。。。{
};
模板
自动获取（tuple&t）{
返回static_cast（&t）->elem；
}
int main（）{
元组指数ti；
std：：cout这并不难。下面是一个如何做到这一点的例子（不是说只有一种方法，这是我很快拼凑起来的）：

#包括
#包括
模板
结构元组{
元素；
};
模板结构元组\u impl；
模板
结构tuple_impl:tuple_leaf…{}；
模板
结构元组：tuple_impl{}；
//下面的行是用于测试的
元组；
//这个编译的事实告诉我们char*有索引2
auto&z=静态_转换（tup）；
谢谢。但是通过测试，我意识到我们失去了所有的类型安全性。你知道为什么下面链接上的程序会编译吗，我将
double
分配给
std:：string
？@meguli这是一个完全不同的问题。
std:：string k；k=3.14；
编译。如果你不确定为什么，你应该问另一个问题。Res我不能保证，这里没有丢失任何类型安全性。哇，它完全可以编译。我的错，对不起！只是简单地澄清一下，你通过
make\u index\u sequence
将一个
index\u sequence
传递给
tuple\u impl
，但是
size\u…Ix
的部分专门化被实例化了。我很难准确地理解这个工作是如何进行的ks。你能解释一下吗？@meguli不太清楚你在问什么。如果合适的话，部分专业化总是比一般模板更受欢迎。
#include <utility>
#include <cstddef>

template <std::size_t I, typename T>
struct tuple_leaf {
    T elem;
};

template<class SEQ, class... TYPE> struct tuple_impl;

template<size_t... Ix, class... TYPE>
struct tuple_impl<std::index_sequence<Ix...>, TYPE...> : tuple_leaf<Ix, TYPE>... { };

template<typename... Ts>
struct tuple : tuple_impl<std::make_index_sequence<sizeof...(Ts)>, Ts...> { };


// below lines are for testing
tuple<int, double, char*> tup;

// the fact that this compiles tells us char* has index 2
auto& z = static_cast<tuple_leaf<2, char*>&>(tup);