Tuple

头文件: "boost/tuple/tuple.hpp"

它包含了 tuple 类模板及库的核心部分。

Header: "boost/tuple/tuple_io.hpp"

包含了对 tuple 的输入输出操作符。

Header: "boost/tuple/tuple_comparison.hpp"

包含了 tuple 的关系操作符。

Tuple 库位于 boost 里的嵌套名字空间 boost::tuples 中。要使用 tuples, 需要包含 "boost/tuple/tuple.hpp", 它包含了核心库。要进行输入输出操作，就包含 "boost/tuple/tuple_io.hpp", 要支持 tuple 的比较，就包含 "boost/tuple/tuple_comparison.hpp". 有些 Boost 库提供一个包含了所有相关库的头文件以方便使用；但 Boost.Tuple 没有。原因是把库分到各个不同的头文件中可以减少编译时间；如果你不使用关系操作符，你就无须为此付出时间和依赖性的代价。为了方便使用，Tuple 库中有些名字位于名字空间 boost：如 tuple, make_tuple, tie, 和 get. 以下是 Boost.Tuple 的部分摘要，列出并简要讨论了最主要的一些函数。

namespace boost {

  template <class T1,class T2,...,class TM> class tuple {
  public:
    tuple();

    template <class P1,class P2...,class PM> 
      tuple(class P1,class P2,...,PN); 

    template <class U1,class U2,...,class UN>
    tuple(const tuple<U1,U2,...,UN>&);

    tuple& operator=(const tuple&);
  };

  template<class T1,class T2,...,class TN> tuple<V1,V2,...,VN> 
    make_tuple(const T1& t1,const T2& t2,...,const TN& tn);

  template<class T1,class T2,...,class TN> tuple<T1&,T2&,...,TN> 
    tie(T1& t1,T2& t2,...,TN& tn);

  template <int I,class T1,class T2,...,class TN> 
    RI get(tuple<T1,T2,...,TN>& t);

  template <int I,class T1,class T2,...,class TN> 
    PI get(const tuple<T1,T2,...,TN>& t);

  template <class T1,class T2,...,class TM,
           class U1,class U2,...,class UM>
    bool operator==(const tuple<T1,T2,...,TM>& t,
                    const tuple<U1,U2,...,UM>& u);

  template <class T1,class T2,...,class TM,
           class U1,class U2,...,class UM>
    bool operator!=(const tuple<T1,T2,...,TM>& t,
                   const tuple<U1,U2,...,UM>& u);

  template <class T1,class T2,...,class TN,
           class U1,class U2,...,class UN>
    bool operator<(const tuple<T1,T2,...,TN>&, 
                  const tuple<U1,U2,...,UN>&);
}

成员函数

tuple();

tuple 的缺省构造函数初始化所有元素，这意味着这些元素必须是可以缺省构造的，它们必须有一个公有的缺省构造函数。任何从这些所含元素的构造函数抛出的异常都会被传播。

template <class P1,class P2...,class PM> 
  tuple(class P1,class P2,...,PN);

这个构造函数接受一些参数，用于初始化 tuple 相应元素。对于一些带有非缺省构造类型的 tuple ，就需要用这种构造方式；不能缺省构造一个 tuple 而不构造它的所有元素。例如，引用类型的元素必须在构造时初始化。注意，参数的数量不必与 tuple 类型中的元素数量一致。可以仅给出部分元素的值，而让剩余元素初始化为缺省值。任何从元素的构造函数抛出的异常都会被传播。

template <class U1,class U2,...,class UN>
  tuple(const tuple<U1,U2,...,UN>&);

这个构造函数用来自另一个 tuple 的元素来进行初始化，要求被构造的 tuple (T1, T2,…,TM) 的每一个元素都必须可以从 (U1,U2,…,UN) 构造。任何从元素的构造函数抛出的异常都会被传播。

TIndex & get<int Index>();
const TIndex & get<int Index>() const;

返回位于给定的 Index 处的元素的引用。Index 必须是一个常量整型表达式；如果索引大于或等于 tuple 中的元素数量，将产生一个编译期错误。结果的类型通过相应的模板参数 TIndex 给出。

tuple& operator=(const tuple& other);

tuple 的赋值要求两个 tuples 具有相同的长度和元素类型。*this 中的每一个元素被赋值为 other 的对应元素。元素赋值中的任何异常都会被传播。

普通函数

template<class T1,class T2,...,class TN> tuple<V1,V2,...,VN> 
  make_tuple(const T1& t1,const T2& t2,...,const TN& tn);

函数模板 make_tuple 是 tuple 版本的 std::make_pair. 它使用函数模板参数推断来决定一个包含这些参数的 tuple 的元素类型。创建这个 tuple 的元素类型时不使用这些参数的高级 cv-限定符。要控制对引用类型的类型推断，可以使用 Boost.Ref 的工具 ref 和 cref 来包装这些参数，从而影响返回的 tuple 结果类型。(稍后我们将看到关于 ref 和 cref 的更多内容)

template<class T1,class T2,...,class TN> tuple<T1&,T2&,...,TN> 
  tie(T1& t1,T2& t2,...,TN& tn);

函数模板 tie 类似于 make_tuple. 调用 tie(t1,t2,...,tn) 等同于调用 make_tuple(ref(t1),ref(t2)... ref(tn))，即它创建一个由函数参数的引用组成的 tuple 。实际结果是把一个 tuple 赋值为由 tie 创建的对象，拷贝源 tuple 的元素到 tie 的参数。这样，tie 可以很容易地从一个由函数返回的 tuple 拷贝值到一个已有变量中。你也可以让 tie 从一个 std::pair 创建一个 2-tuple 。

template <int I,class T1,class T2,...,class TN> 
  RI get(tuple<T1,T2,...,TN>& t);

这个函数 get 的重载版本用于取出 tuple t 的一个元素。索引 I 必须位于范围 [0..N), N 为 tuple 中的元素数量。如果 TI 是一个引用类型，则RI 为 TI; 否则, RI 为 TI&.

template <int I,class T1,class T2,...,class TN> 
  RI get(const tuple<T1,T2,...,TN>& t);

这个函数 get 用于取出 tuple t 的一个元素。索引 I 必须位于范围 [0..N), N 为 tuple 中的元素数量。如果 TI 是一个引用类型，则RI 为 TI; 否则, RI 为 const TI&.

关系操作符

bool operator==(
  const tuple<T1,T2,...,TN>& lhs, 
  const tuple<U1,U2,...,UN>& rhs);

如果对于所有位于范围[0..N)的 i，都有 get<i>(lhs)==get<i>(rhs) ，N 为元素数量，则相等操作符返回 true 。这两个 tuples 必须具有相同数量的元素。对于 N=0 的空 tuple ，总是返回 true 。

bool operator!=(
  const tuple<T1,T2,...,TN>& lhs, 
  const tuple<U1,U2...,...,>& rhs);

如果对于任意一个位于范围[0..N)的 i，有 get<i>(lhs)!=get<i>(rhs) ，N 为元素数量，则不等操作符返回 true 。这两个 tuples 必须具有相同数量的元素。对于 N=0 的空 tuple ，总是返回 false 。

bool operator<(
  const tuple<T1,T2,...,TN>& lhs, 
  const tuple<U1,U2,...,UN>& rhs);

如果对于任意一个位于范围[0..N)的 i，有 get<i>(lhs)<get<i>(rhs) ，N 为元素数量，则小于操作符返回 true ；假如对每个比较都返回 false，则表达式 !(get<i>(rhs)<get<i>(lhs)) 为 true；否则表达式为 false。这两个 tuples 必须具有相同数量的元素。对于 N=0 的空 tuple ，总是返回 true 。

值得注意的是，对于所有支持的关系操作符(operators ==, !=, <, >, <=, 和 >=), 两个 tuples 必须有相同的约束。首先，它们必须有相同的长度。其次，两个 tuple 间的每对元素(第一个对第一个，第二个对第二个，等等)必须支持同一个关系操作符。当这些约束被满足时，tuple 的操作符才可以实现，它按顺序比较每一对元素，即关系操作符是短路(short-circuited)的，一旦有了明确结果就马上返回。操作符 <, >, <=, 和 >= 执行字典序的比较，并要求元素对执行同样的操作。元素对的比较操作符产生的任何异常都会被传播，但 tuple 操作符本身不抛出异常。