我想知道元组是如何在 C++0x 的标准库中实现的。我尝试阅读description in libstdc++ manual，然后阅读template listing，但很难理解它是如何工作的，尤其是在阅读代码时。
有人可以用几句话向我解释元组实现的想法吗？我想知道这一点，因为我考虑在我的代码中使用元组，我想了解它是如何工作的以及它带来了什么类型的开销（仅延长编译时间，在内存上执行许多复制操作，在构造函数中执行许多其他函数等）。
【问题讨论】：
实现元组的一种方法是使用多重继承。元组元素由叶类持有，元组类本身继承自多个叶。在伪代码中：
template<typename T0, typename T1, ..., typename Tn>
class PseudoTuple : TupleLeaf<0, T0>, TupleLeaf<1, T1>, ..., TupleLeaf<n, Tn> {
...
};
每个叶子都有一个索引，因此即使它们包含的类型相同，每个基类也变得唯一，因此我们可以使用简单的 static_cast 访问 nth 元素：
static_cast<TupleLeaf<0, T0>*>(this);
// ...
static_cast<TupleLeaf<n, Tn>*>(this);
我在这里写了关于这个“扁平”元组实现的详细解释：C++11 tuple implementation details (Part 1)
【讨论】：
我以为我会添加一个非伪代码的简单递归实现以供参考
#include <iostream>
// Contains the actual value for one item in the tuple. The
// template parameter `i` allows the
// `Get` function to find the value in O(1) time
template<std::size_t i, typename Item>
struct TupleLeaf {
Item value;
};
// TupleImpl is a proxy for the final class that has an extra
// template parameter `i`.
template<std::size_t i, typename... Items>
struct TupleImpl;
// Base case: empty tuple
template<std::size_t i>
struct TupleImpl<i>{};
// Recursive specialization
template<std::size_t i, typename HeadItem, typename... TailItems>
struct TupleImpl<i, HeadItem, TailItems...> :
public TupleLeaf<i, HeadItem>, // This adds a `value` member of type HeadItem
public TupleImpl<i + 1, TailItems...> // This recurses
{};
// Obtain a reference to i-th item in a tuple
template<std::size_t i, typename HeadItem, typename... TailItems>
HeadItem& Get(TupleImpl<i, HeadItem, TailItems...>& tuple) {
// Fully qualified name for the member, to find the right one
// (they are all called `value`).
return tuple.TupleLeaf<i, HeadItem>::value;
}
// Templated alias to avoid having to specify `i = 0`
template<typename... Items>
using Tuple = TupleImpl<0, Items...>;
int main(int argc, char** argv) {
Tuple<int, float, std::string> tuple;
Get<0>(tuple) = 5;
Get<1>(tuple) = 8.3;
Get<2>(tuple) = "Foo";
std::cout << Get<0>(tuple) << std::endl;
std::cout << Get<1>(tuple) << std::endl;
std::cout << Get<2>(tuple) << std::endl;
return 0;
}
【讨论】：
TupleImpl<0, int, float, std::string> tuple; 进行初始化，当我调用Get<1>(tuple) 时，调用不等于Get(TupleImpl<1, int, {float,std::string}>& tuple)。既然TupleLeaf<1, int> 不存在，这不应该失败吗？
Get<1>(tuple) 时，参数会从TupleImpl<0, int, float, std::string> 向上转换为TupleImpl<1, float, std::string>。由于前导整数模板参数的值，这种向上转换是唯一可能的。请注意，upcast 删除了 int 模板参数。这是因为随着前导整数模板参数的增加，类型模板参数在继承层次结构中被一一删除。因此Get<1>(tuple) 最终调用tuple.TupleLeaf<1, float>::value，这是有效的。
元组通常实现为编译时链表。
代码通过模板语法有点混淆，但通常存在以下元素：
在 C++03 中存在合理的实现（例如 boost）。
如 Motti 所述，可变参数模板允许无限数量的元素。
成本通常是编译时间。复制构造函数可能会在初始化期间（最多 1 个）以及复制元组本身时被调用。
【讨论】：
可以通过引入核心语言的variadic templates 实现std::tuple。
我知道这是在乞求问题，但它为您提供了更好的搜索短语来研究。
【讨论】：
通过组合而不是继承使用递归数据结构的实现：
#include <iostream>
template <typename T, typename... Ts>
struct Tuple {
Tuple(const T& t, const Ts&... ts)
: value(t)
, rest(ts...)
{
}
constexpr int size() const { return 1 + rest.size(); }
T value;
Tuple<Ts...> rest;
};
template <typename T>
struct Tuple<T> {
Tuple(const T& t)
: value(t)
{
}
constexpr int size() const { return 1; }
T value;
};
template <size_t i, typename T, typename... Ts>
struct nthType : nthType<i-1, Ts...> {
static_assert(i < sizeof...(Ts) + 1, "index out of bounds");
};
template <typename T, typename... Ts>
struct nthType<0, T, Ts...> { T value; };
template <size_t i>
struct getter {
template <typename... Ts>
static decltype(nthType<i, Ts...>::value)& get(Tuple<Ts...>& t) {
return getter<i-1>::get(t.rest);
}
};
template <>
struct getter<0> {
template <typename T, typename... Ts>
static T& get(Tuple<T, Ts...>& t) {
return t.value;
}
};
template <size_t i, typename... Ts>
decltype(nthType<i, Ts...>::value)& get(Tuple<Ts...>& t) {
return getter<i>::get(t);
}
int main()
{
Tuple<int,int,float> t(1,2,3.4);
std::cout << get<0>(t) << "\n";
std::cout << get<1>(t) << "\n";
std::cout << get<2>(t) << "\n";
// std::cout << get<3>(t) << "\n"; // error with useful information
return 0;
}
我发现这种方法比其他方法要好得多，因为它在执行 apply map 等递归操作时使用起来非常直观，尤其是如果您曾经在函数式编程中使用过递归数据结构。当然，对于索引检索，我们需要做一些奇怪的模板的东西，但一般使用递归性质是非常直观的。如果有人能解释为什么这种设置不常见，我很想知道。
【讨论】：