前言

    tuple 是类似于pair的模板。每个pair的成员类型都不相同，但每个pair都恰好有两个成员。不同tuole类型的也不相同，但一个tuple可以有任意数量的成员。每个确定的tuple类型的成员数目是固定的，但一个tuple类型的成员数目可以与另一个tuple类型不同。

当我们希望将一些数据组合成单一对象，但又不想麻烦地定义一个新数据来表示这些数据时，tuple是非常有用的。

例如我们可以构造一个tuple

tuple<const char*, int>tp = make_tuple(sendPack,nSendSize);

这个tuple等价于一个结构体

struct A{  char* p;  int len;};

    用tuple<const char*, int>tp就可以不用创建这个结构体了，而作用是一样的，是不是更简洁直观了

还有一种方法也可以创建元组，用std::tie，它会创建一个元组的左值引用。

auto tp = return std::tie(1, "aa", 2);

tp的类型实际是：

std::tuple<int&,string&, int&>

tuple初印象

 tuple支持如下的操作

std::tuple<T1, T2, ...TN> t;            //创建一个空的tuple对象（使用默认构造），它对应的元素分别是T1和T2...Tn类型，采用值初始化。std::tuple<T1, T2, ...TN> t2(v1, v2, ... vn);    //创建一个tuple对象，它的元素分别是T1和T2 ...Tn类型; 每个成员用对应的vi进行初始化std::tuple<T1&> t3(ref&); // tuple的元素类型可以是一个引用

像pair一样也可以通过make_tuple进行创建一个tuple对象，tuple的类型从初始值的类型推断

std::make_tuple(v1, v2); 

返回t的第i个数据成员的引用：如果t是一个左值，结果是一个左值引用；否则，结果是一个右值引用。此外tuple的所有成员都是pulic的。

get<i>(t)

   我们可以将tuple看作一个“快速而随意”的数据结构。

定义和初始化tuple

当我们定义一个std::tuple时，需要指出每个成员的类型。

tuple<size_t,size_t,size_t> threeD; //三个成员都被设置为0
tuple<string,vector<doble>,int ,list<int>> someVal("constans",{3.14,2.718},42,{0,1,2,3,4,5});

    当我们创建一个std::tuple对象时，可以使用tuple的默认构造函数，它会对每个成员进行值初始化；也可以向上面someVal初始化一样，为每个成员提供一个初始值，此时的构造函数是explicit的，因此必须使用直接初始化方法。

tuple<size_t,size_t,size_t> htreeD = {1,2,3};tuple<size_t,size_t,size_t> htreeD(1,2,3);

类似make_pair函数，标准库定义了make_tuple函数，我们还可以使用它来生成std::tuple对象。

auto item = mak_tuple("0-999-78345-x",3,20.00);

    类似make_pair，make_tuple函数使用初始值的类型来推断tuple的类型。在上面示例中，item是一个tuple，类型为tuple<const char*,int ,double> .

访问tuple的成员  

    一个pair总是有两个成员，这样标准库就可以为他们命名（first和second），但是这种命名方法不适用于tuple，因为一个tuple的类型的成员数目是没有限制的。因为，tuple的成员都是未命名的。要访问一个tuple的成员，就要使用一个名为get的标准库函数模板。为了使用get，我们必须指定一个显示模板实参，它指出我们想要访问第几个成员。我们传递给get一个tuple对象，它返回指定成员的引用。

auto book  = get<0>(iterm); //返回iterm的第一个成员auto cnt  = get<0>(iterm); //返回iterm的第二个成员auto price  = get<0>(iterm)/cnt; //返回iterm的第三个成员

尖括号中的值必须是一个整型常量表达式，与平时一样，我们从0开始计数，意味着get<0>是第一个成员。

如果不知道tuple准确的类型细节信息，可以用两个辅助类模板查询tuole的成员的数量和类型：

    1.一个类模板，可以通过一个tuple类型初始化，它有一个名为value的public constexpr static数据类型，类型为size_t,表示给定tuple类型中成员数量

tuple_element<i,tupleType>::type

    2.一个类模板，可以通过一个整型常量和一个tuple类型来初始化。它有一个名为type的public成员，表示给定tuple类型中指定的类型      

tuple_size<tupleType>::value

通过这两个类模板我们可以获得我们需要的tuple变量的成员数量和类型

typedef decltype（item） trans；//trans是item的类型
size_t sz = tuple_size< trans>::value；//返回trans类型对象中成员的数量
tuple_element<1,trans>::type cnt ; // cnt 为 item第二个成员变量类型  int型
cnt = get<1>(item);

    为了使用tuple_size或tuple_element,我们需要知道一个tuple对象的类型。与往常一样，确定一个对象的类型的最简单的方法就是使用decltype，在typedef decltype（item） trans；中，我们使用decltype来为item定义一个类型别名，用它来实例化这两个模板。

    tuple_size有一个名为value的public static数据成员，它表示给定tuple中成员的数量。  tuple_element模板除了一个tuple类型外，还接受一个索引值。它有一个名为type的public类型成员，表示给定tuple类型中指定成员类型。类似get，tuple_element所使用的索引也是从0开始计数的。

    std::tuple的关系和相等运算符的行为类似容器的对应操作。这些运算符逐对比较左侧tuple和右侧tuple的成员。只有两个tuple具有相同数量的成员时，我们才可以比较它们。而且，为了使用tuple的相等或不等运算符，对每对成员使用==运算符必须都是合法的；为了使用关系运算符，对每对成员使用 <  必须都是合法的。

    关系和相等运算符：当两个tuole具有相同数量的成员且成员对应相等时，两个才tuple相同。

tuple<string,string> duo("1","2");tuple<size_t,size_t> twoD(1,2);
bool b = (duo == twoD); // 错误，不能比较size_t 和 string
tuple<size_t,size_t,size_t> threeD(1,2,3); b = (duo == threeD); // 错误，成员数量不同tuple<size_t,size_t> origin(0,0); b = (origin < twoD); // 正确：b为true

    由于tuple定义了<和==运算符，我们可以将tuple序列传递给算法，并且可以在无序容器中将tuple作为关键字类型。

利用tie进行解包元素的值

 如同pair一样也是可以通过tie进行解包tuple的各个元素的值。如下tuple对象有4个元素，通过tie解包将会把这4个元素的值分别赋值给tie提供的4个变量中。

int main(int argc, char **argv) {    std::tuple<std::string, int, std::string, int> tp;    tp = std::make_tuple("Sven", 25, "Shanghai", 21);    // 定义接收变量    std::string name;    std::string addr;    int ages;    int areaCode;     std::tie(name, ages, addr, areaCode) = tp;    std::cout << "Output: " << '\n';    std::cout << "name: " << name <<", ";    std::cout << "addr: " << addr << ", ";    std::cout << "ages: " << ages << ", ";    std::cout << "areaCode: " << areaCode << '\n';    return 0;}

输出结果：

name: Sven, addr: Shanghai, ages: 25, areaCode: 21

但有时候tuple包含的多个元素时只需要其中的一个或两个元素，如此可以通过std::ignore进行变量占位，这样将会忽略提取对应的元素。可以修改上述例程：

std::tie(name, ages, std::ignore, std::ignore) = tp;

    std::tuple中元素是被紧密地存储的(位于连续的内存区域)，而不是链式结构。

如何遍历tuple成员

N表示tuple中的第N个元素

#include <iostream>#include <tuple>#include <string> using namespace std; template<typename Tuple, int N = std::tuple_size<Tuple>::value>struct Printer{  static void log(Tuple& t) {    Printer<Tuple, N - 1>::log(t);     using type = typename std::tuple_element<N - 1, Tuple>::type;    std::string ts = typeid(type).name();    type& v = std::get<N - 1>(t);     std::cout << ts << ":" << v << std::endl;  }}; template<typename Tuple>struct Printer<Tuple,  1>{  static void log(Tuple& t) {    using type = typename std::tuple_element<0, Tuple>::type;    std::string ts = typeid(type).name();    type& v = std::get<0>(t);     std::cout << ts << ":" << v << std::endl;  }}; int main() {  std::tuple<int, bool, string> t = std::forward_as_tuple(11, true, "ok");  Printer<std::tuple<int, bool, string>>::log(t);   return 1;}

tuple做返回相关作用  

使用tuple返回多个值，tuple的一个常见用途就是从一个函数返回多个值。

返回tuple的函数

tuple<int, string> fun(){        // 用make_tuple来构造一个tuplereturn make_tuple(1024, "tuple"，'3');}

使用函数返回的tuple

auto tp = fun();auto id      = std::get<0>(tp);
auto name= std::get<1>(tp);
auto num  = std::get<2>(tp);

 这就是我分享的C++多元组tuple，里面知识是实践过的，如果大家有什么更好的思路，欢迎交流哈。

—END—