C++tuple类型

 tuple 类型

tuple是类似pair的模板。

• 每个pair的成员类型都不相同，但每个pair都恰好有两个成员。
• 不同tuple类型的成员类型也不相同，但一个tuple可以有任意数量的成员。

每个确定的tuple类型的成员数目是固定的，但一个tuple类型的成员数目可以与另一个tuple类型不同。

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

tuple类型及其伴随类型和函数都定义在tuple头文件中。
 

tuple支持的操纵

tuple<T1, T2， ..., Tn> t；	t是一个tuple，成员数为n，第i个成员的类型为Ti.所有成员都进行值初始化
tuple<T1, T2, ...,Tn>t(v1，v2, ..., vn)；	t是一个tuple，成员类型为T1...Tn，每个成员用对应的初始值vi进行初始化。此构造函数是explicit的
make_tuple(v1, v2, ..., vn)	返回一个用给定初始值初始化的 tuple。tuple 的类型从初始值的类型推断
t1==t2 t1!=t2	当两个 tuple具有相同数量的成员且成员对应相等时，两个tuple相等。 这两个操作使用成员的==运算符来完成。一旦发现某对成员不等，接下来的成员就不用比较了
t1 relop t2	tuple的关系运算使用字典序。 两个tuple必须具有相同数量的成员。使用<运算符比较t1的成员和t2中的对应成员
get<i>(t)	返回t的第i个数据成员的引用；如果t是一个左值，结果是一个左值引用；否则，结果是一个右值引用。tuple的所有成员都是public的
tuple_size<tupleType>::value	一个类模板，可以通过一个tuple类型来初始化。它有一个名为value的public constexpr static数据成员，类型为size_t，表示给定tuple类型中成员的数量
tuple_element<i,  tupleType>::type	一个类模板，可以通过一个整型常量和一个 tuple类型tupleType>::type 来初始化。它有一个名为type的public成员，表示给定tuple类型中指定成员的类型

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

定义和初始化tuple

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

#include<iostream>
#include<tuple>
#include<vector>
#include<list>
#include<string>
using namespace std;

int main()
{
	tuple<string,
		size_t, size_t> threeD; //三个成员都设置为0
	tuple<string, vector<double>, int, list<int>>
		someval("constants", { 3.14, 2, 718 }, 42, { 0,1,2,3,4,5 });
}

当我们创建一个tuple对象时，可以使用 tuple的默认构造函数，它会对每个成员进行提供一个初始值。

也可以像本例中初始化nomeval一样，为每个成员提供一个初始值

tuple的这个构造函数是explicit的因此我们必须使用直接初始化语法：

	tuple<size_t, size_t, size_t> threeD = (1, 2, 3); // 错误
	tuple<size_t, size_t, size_t> threeD(1, 2, 3); // 正确

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

auto item = make_tuple("0-999-78345-X", 3,  20.00);

类似 make_pair，make_tuple 函数使用初始值的类型来推断 tuple的类型。

在本例中，item是一个tuple，类型为 tuple<const char*, int, double>。

也就是说，上面这个和下面这个等效

tuple<const char*, int, double>item("0-999-78345-X", 3, 20.00);
//注意不能tuple<const char*, int, double>item=("0-999-78345-X", 3, 20.00);

访问 tuple的成员

一个pair总是有两个成员，这样，标准库就可以为它们命名(如，first和second)。

但这种命名方式对tuple是不可能的，因为一个tuple类型的成员数目是没有限制的。

因此，tuple的成员都是未命名的。

要访问一个tuple的成员，就要使用一个名为get的标准库函数模板。为了使用get，我们必须指定一个显式模板实参，它指出我们想要访问第几个成员。

我们传递给get一个tuple对象，它返回指定成员的引用：

auto item = make_tuple("0-999-78345-X", 3,  20.00);
auto& book = get<0>(item); //返回item的第一个成员，注意在auto后面加上&
cout << book << endl;
book = "nihao";
cout << get<0>(item) << endl;

auto cnt = get<1>(item); //返回item的第二个成员
	auto price = get<2>(item) / cnt; // 返回item的最后一个成员
get<2>(item) *= 0.8; // 打折20号

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

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

	auto item = make_tuple("0-999-78345-X", 8, 20.00);
	typedef decltype(item) trans;// trans是item的类型
	// 返回trans类型对象中成员的数量
	size_t sz = tuple_size<trans>::value; //返回3
	cout << sz << endl;
	
	// cnt的类型与item中第二个成员相同
	tuple_element<1, trans>::type cnt = get<1>(item); // cnt是一个int
	cout << cnt << endl;

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

tuple_size有一个名为value的public static数据成员，它表示给定tuple中成员的数量。

tuple_element 模板除了一个tuple类型外，还接受一个索引值。它有一个名为type的public类型成员，表示给定tuple类型中指定成员的类型。

类似get, tuple element所使用的索引也是从0开始计数的。

关系和相等运算符

tuple的关系和相等运算符的行为类似容器的对应操作。

这些运算符逐对比较左侧tuple和右侧tuple的成员。

1. 只有两个 tuple 具有相同数量的成员时，我们才可以比较它们。
2. 而且，为了使用tuple的相等或不等运算符，对每对成员使用==运算符必须都是合法的；
3. 为了使用关系运算符，对每对成员使用<必须都是合法的。

例如：

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 = (twoD < threeD); //错误：成员数量不同
tuple<size_t, size_t> origin(0, 0);
b = (origin < twoD); // 正确：b为true

在C++中，std::tuple 类型的比较行为由它包含的元素的比较行为决定。

默认情况下，你不能比较包含不同类型元素的 std::tuple 对象，就像在你的第一个比较中那样，一个包含 std::string 类型的 tuple 和一个包含 size_t 类型的 tuple 是不能比较的，因为 std::string 和 size_t 之间没有定义比较操作。

在你的第二个比较中，尝试比较成员数量不同的 std::tuple 对象，这同样是不允许的。std::tuple 的比较要求两个 tuple 的长度（即包含的元素的数量）必须相同。

第三个比较是正确的，因为 origin 和 twoD 都是 std::tuple<size_t, size_t> 类型，它们包含相同数量和类型的元素，因此可以进行比较。在你的例子中，origin 是 (0, 0)，twoD 是 (1, 2)，因此 origin < twoD 会返回 true。

总的来说，你可以比较两个 std::tuple 对象，只要它们满足以下条件：

1. 两个 tuple 的长度（元素数量）必须相同。
2. 对应位置的元素类型必须能够进行比较。

如果你想比较不同类型的 tuple，你需要自定义比较逻辑，或者使用某种方式将 tuple 中的元素转换为可以比较的类型。

但请注意，这通常不是 std::tuple 的典型用法，因为 std::tuple 主要用于将不同类型的值组合成一个单一的对象，而不是用于比较操作。如果你需要频繁地比较不同类型的值，可能需要考虑使用其他数据结构或自定义类型。

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

使用 tuple返回多个值

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

返回tupe的函数

在C++中，std::tuple 是一个模板类，它可以将多个值组合成一个单一的对象，其中每个值都可以是任意类型。当你需要从一个函数中返回多个值时，std::tuple 是一个很好的选择，因为C++不直接支持从函数中返回多个值。

下面是一个简单的例子，演示了如何定义一个返回 std::tuple 的函数：

#include <iostream>
#include <tuple>

// 定义一个返回 std::tuple 的函数
std::tuple<int, std::string, double> get_values() {
    int a = 10;
    std::string b = "Hello";
    double c = 3.14;
    // 使用 std::make_tuple 创建并返回 tuple
    return std::make_tuple(a, b, c);
}

int main() {
    // 调用函数并获取返回的 tuple
    auto values = get_values();

    // 使用 std::get 来获取 tuple 中的特定值
    int int_value = std::get<0>(values);
    std::string str_value = std::get<1>(values);
    double double_value = std::get<2>(values);

    // 输出获取到的值
    std::cout << "Int: " << int_value << std::endl;
    std::cout << "String: " << str_value << std::endl;
    std::cout << "Double: " << double_value << std::endl;

    return 0;
}

在这个例子中，get_values 函数返回一个包含 int、std::string 和 double 类型的 std::tuple。在 main 函数中，我们调用 get_values 函数，并使用 auto 关键字来自动推断返回值的类型。然后，我们使用 std::get 函数来访问 tuple 中的每个元素，并打印它们。

注意，std::get 的第一个模板参数是元素在 tuple 中的位置（从0开始）。

使用函数返回的 tuple

在C++中，函数可以返回std::tuple，它是一个固定大小的异类容器，可以存储不同类型的元素。使用函数返回tuple是一种方便的方式来返回多个值，而不需要使用结构体或类。

以下是一个关于如何在C++中使用函数返回tuple的详细解释：

1. 包含必要的头文件

首先，你需要包含tuple和utility（为了使用std::make_tuple和std::get）的头文件。

#include <tuple>
#include <utility>

2. 定义返回tuple的函数

你可以定义一个函数，其返回类型为std::tuple，并指定tuple中元素的类型。

std::tuple<int, std::string, double> get_values() {
    int a = 10;
    std::string b = "Hello";
    double c = 3.14;
    return std::make_tuple(a, b, c);
}

在这个例子中，get_values函数返回一个包含int、std::string和double类型元素的tuple。

3. 调用函数并处理返回的tuple

调用返回tuple的函数后，你可以使用std::get来访问tuple中的每个元素。注意，std::get需要元素的索引（从0开始）或类型作为参数。

int main() {
    // 调用函数并获取返回的tuple
    auto values = get_values();
    
    // 使用std::get访问tuple中的元素
    int int_value = std::get<0>(values);
    std::string str_value = std::get<1>(values);
    double double_value = std::get<2>(values);
    
    // 输出值
    std::cout << "Int: " << int_value << std::endl;
    std::cout << "String: " << str_value << std::endl;
    std::cout << "Double: " << double_value << std::endl;
    
    return 0;
}

4. 使用结构化绑定（C++17及更高版本）

从C++17开始，你可以使用结构化绑定来更简洁地处理返回的tuple。结构化绑定允许你直接将tuple的元素绑定到变量上，而无需使用std::get。

int main() {
    // 调用函数并使用结构化绑定处理返回的tuple
    auto [int_value, str_value, double_value] = get_values();
    
    // 输出值
    std::cout << "Int: " << int_value << std::endl;
    std::cout << "String: " << str_value << std::endl;
    std::cout << "Double: " << double_value << std::endl;
    
    return 0;
}

在这个例子中，结构化绑定自动将tuple中的元素绑定到int_value、str_value和double_value变量上，使代码更加简洁易读。

注意事项

1. 确保你的编译器支持C++11或更高版本，因为std::tuple是在C++11中引入的。结构化绑定则需要C++17或更高版本的支持。
2. 当处理复杂的tuple或需要在多个地方访问其元素时，考虑使用命名元组库（如Boost.Hana或std::apply与lambda表达式）以提高代码的可读性和可维护性。