C++类模板tuple（元组C++11）和pair的简单使用

港控/mmm° 2022-12-28 01:39 130阅读 0赞

# tuple（元组） #

定义于头文件 `<tuple>，C++11特性；`

## `简介` ##

tuple是一个固定大小的异类值汇集，也就是说tuple是一个**固定大小**的不同类型值的集合，是泛化的std::pair。我们也可以把他当做一个通用的结构体来用，不需要创建结构体又获取结构体的特征，在某些情况下可以取代结构体使程序更简洁，直观。std::tuple理论上可以有无数个任意类型的成员变量，而std::pair只能是2个成员，因此在需要保存3个及以上的数据时就需要使用tuple元组了。

等价结构体

struct person {
        char *m_name;
        char *m_addr;
        int  *m_ages;
    };
     
    //可以用tuple来表示这样的一个结构类型，作用是一样的。
    std::tuple<const char *, const char *, int>

## tuple的创建和初始化 ##

>   
> std::tuple<T1, T2, TN> t1; //创建一个空的tuple对象（使用默认构造），它对应的元素分别是T1和T2...Tn类型，采用值初始化。  
> std::tuple<T1, T2, TN> t2(v1, v2, ... TN); //创建一个tuple对象，它的N个元素分别是T1和T2 ...Tn类型; 要获取元素的值需要通过tuple的成员get<Ith>(obj)进行获取(Ith是指获取在tuple中的第几个元素，请看后面具体实例)。  
> std::tuple<T1&> t3(ref&); // tuple的元素类型可以是一个引用  
> std::make\_tuple(v1, v2); // 像pair一样也可以通过make\_tuple进行创建一个tuple对象  
>

## 成员函数 ##

<table> 
 <tbody> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/tuple" rel="nofollow">(构造函数)</a></p> </td> 
   <td>构造新的&nbsp;<code>tuple</code>&nbsp;<br> (公开成员函数)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/operator%3D" rel="nofollow">operator=</a></p> </td> 
   <td>赋值一个&nbsp;<code>tuple</code>&nbsp;的内容给另一个&nbsp;<br> (公开成员函数)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/swap" rel="nofollow">swap</a></p> </td> 
   <td>交换两个&nbsp;<code>tuple</code>&nbsp;的内容&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

## 非成员函数 ##

<table> 
 <tbody> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/make_tuple" rel="nofollow">make_tuple</a></p> </td> 
   <td>创建一个&nbsp;<code>tuple</code>&nbsp;对象，其类型根据各实参类型定义&nbsp;<br> (函数模板)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/tie" rel="nofollow">tie</a></p> </td> 
   <td>创建左值引用的&nbsp;<code>tuple</code>，或将 tuple 解包为独立对象&nbsp;<br> (函数模板)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/forward_as_tuple" rel="nofollow">forward_as_tuple</a></p> </td> 
   <td>创建<a href="https://zh.cppreference.com/w/cpp/language/reference#.E8.BD.AC.E5.8F.91.E5.BC.95.E7.94.A8" rel="nofollow">转发引用</a>的&nbsp;<code>tuple</code>&nbsp;<br> (函数模板)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/tuple_cat" rel="nofollow">tuple_cat</a></p> </td> 
   <td>通过连接任意数量的元组来创建一个<code>tuple</code>&nbsp;<br> (函数模板)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/get" rel="nofollow">std::get(std::tuple)</a></p> </td> 
   <td>元组式访问指定的元素&nbsp;<br> (函数模板)</td> 
  </tr> 
 </tbody> 
</table>

## 辅助类 ##

<table> 
 <tbody> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/tuple_size" rel="nofollow">tuple_size</a></p> </td> 
   <td>在编译时获得&nbsp;<code>tuple</code>&nbsp;的大小&nbsp;<br> (类模板特化)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/tuple_element" rel="nofollow">tuple_element</a></p> </td> 
   <td>获得指定元素的类型&nbsp;<br> (类模板特化)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/uses_allocator" rel="nofollow">std::uses_allocator&lt;std::tuple&gt;</a></p> <p>(C++11)</p> </td> 
   <td>特化&nbsp;<a href="https://zh.cppreference.com/w/cpp/memory/uses_allocator" rel="nofollow">std::uses_allocator</a>&nbsp;类型特征&nbsp;<br> (类模板特化)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/tuple/ignore" rel="nofollow">ignore</a></p> </td> 
   <td>用&nbsp;<a href="https://zh.cppreference.com/w/cpp/utility/tuple/tie" rel="nofollow">tie</a>&nbsp;解包&nbsp;<code>tuple</code>&nbsp;时用来跳过元素的占位符&nbsp;<br> (常量)</td> 
  </tr> 
 </tbody> 
</table>

#include <iostream>
    #include<string>
    #include<set>
    #include<algorithm>
    #include<iterator>
    #include<vector>
    #include<tuple>
    using namespace std;
    
    
    int main()
    {
    	//1. tuple 构造函数初始化
    	tuple<int, string, int, double> t1;
    	tuple<int, string, int, double> t2(12, "hello", 34, 5.6);
    	t1 = t2;
    
    	//2.使用 std::make_tuple 生成tuple对象
    	tuple<int, int, int, double> t3 = make_tuple(1, 2, 3, 4.5);
    
    	//3.获取元组元素个数--std::tuple_size
    
    	cout << "t1元素个数："<< tuple_size<decltype(t1)>::value << endl;
    
    	//4.获取第i个元素--std::get<i>(tuple)
    	cout << "t2的第二个元素: "<< get<2>(t2) << endl;
    
    
    	// tuple 不支持迭代，只能通过元素索引(或tie解包)进行获取元素的值。
    	// 但是给定的索引必须是在编译器就已经给定，不能在运行期进行动态传递，否则将发生编译错误：
    	//for (int i = 0; i < 3; i++)
    	//	std::cout << std::get<i>(t3) << " "; //将引发编译错误
    
    	//5.获取元素的类型
    	std::tuple<std::string, int> tp("Sven", 20);
    
    	// 得到第二个元素类型
    	std::tuple_element<1, decltype(tp)>::type ages; 
    	// ages 就为int类型
    	ages = std::get<1>(tp);
    	std::cout << "ages: " << ages << '\n';
    
    	//6.利用tie进行解包元素的值
    
    	int one, three;
    	string two;
    	double four;
    
    	//解包
    	tie(one, two, three, four) = t2;
    
    	cout << "t2第0个元素：" << one << endl;
    	cout << "t2第1个元素：" << two << endl;
    	cout << "t2第2个元素：" << three << endl;
    	cout << "t2第3个元素：" << four << endl;
    
    	//7. tuple 元素的引用
    
    	std::tuple<std::string, int, float> tp1("Sven Cheng", 77, 66.1);
    
    	std::string name;
    	int weight;
    	float f;
    
    	auto tp2 = std::make_tuple(std::ref(name), std::ref(weight), std::ref(f)) = tp1;
    
    	std::cout << "Before change: " << '\n';
    	std::cout << "name: " << name << ", ";
    	std::cout << "weight: " << weight << ", ";
    	std::cout << "f: " << f << '\n';
    
    	name = "Sven";
    	weight = 80;
    	f = 3.14;
    
    	std::cout << "After change: " << '\n';
    	std::cout << "element 1st: " << std::get<0>(tp2) << ", ";
    	std::cout << "element 2nd: " << std::get<1>(tp2) << ", ";
    	std::cout << "element 3rd: " << std::get<2>(tp2) << '\n';
    	return 0;
    }
    //结果：
    /*
     *
     t1元素个数：4
    t2的第二个元素: 34
    ages: 20
    t2第0个元素：12
    t2第1个元素：hello
    t2第2个元素：34
    t2第3个元素：5.6
    Before change:
    name: Sven Cheng, weight: 77, f: 66.1
    After change:
    element 1st: Sven, element 2nd: 80, element 3rd: 3.14
     */

# pair #

**定义于头文件 `<utility>`**

`std::pair` 是类模板，提供在一个单元存储两个相异类型对象的途径。 `pair` 是 [std::tuple][std_tuple] 的拥有两个元素的特殊情况。

pair是将2个数据组合成一组数据，当需要这样的需求时就可以使用pair，如stl中的map就是将key和value放在一起来保存。另一个应用是，当一个函数需要返回2个数据的时候，可以选择pair。 pair的实现是一个结构体，主要的两个成员变量是first second 因为是使用struct不是class，所以可以直接使用pair的成员变量。

### 成员对象 ###

<table> 
 <tbody> 
  <tr> 
   <td colspan="2">&nbsp;</td> 
  </tr> 
  <tr> 
   <td>成员名</td> 
   <td>类型</td> 
  </tr> 
  <tr> 
   <td><code>first</code></td> 
   <td><code>T1</code></td> 
  </tr> 
  <tr> 
   <td><code>second</code></td> 
   <td><code>T2</code></td> 
  </tr> 
 </tbody> 
</table>

### 成员函数 ###

<table> 
 <tbody> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/pair" rel="nofollow">(构造函数)</a></p> </td> 
   <td>构造新的 pair&nbsp;<br> (公开成员函数)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/operator%3D" rel="nofollow">operator=</a></p> </td> 
   <td>对 内容赋值&nbsp;<br> (公开成员函数)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/swap" rel="nofollow">swap</a></p> <p>(C++11)</p> </td> 
   <td>交换内容&nbsp;<br> (公开成员函数)</td> 
  </tr> 
 </tbody> 
</table>

### 非成员函数 ###

<table> 
 <tbody> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/make_pair" rel="nofollow">make_pair</a></p> </td> 
   <td>创建一个&nbsp;<code>pair</code>&nbsp;对象，其类型根据各实参类型定义&nbsp;<br> (函数模板)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/operator_cmp" rel="nofollow">operator==operator!=operator&lt;operator&lt;=operator&gt;operator&gt;=operator&lt;=&gt;</a></p> <p>(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20)</p> </td> 
   <td>按字典序比较 pair 中的值&nbsp;<br> (函数模板)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/swap2" rel="nofollow">std::swap(std::pair)</a></p> <p>(C++11)</p> </td> 
   <td>特化&nbsp;<a href="https://zh.cppreference.com/w/cpp/algorithm/swap" rel="nofollow">std::swap</a>&nbsp;算法&nbsp;<br> (函数模板)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/get" rel="nofollow">std::get(std::pair)</a></p> <p>(C++11)</p> </td> 
   <td>访问&nbsp;<code>pair</code>&nbsp;的一个元素&nbsp;<br> (函数模板)</td> 
  </tr> 
 </tbody> 
</table>

### 辅助类 ###

<table> 
 <tbody> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/tuple_size" rel="nofollow">std::tuple_size&lt;std::pair&gt;</a></p> <p>(C++11)</p> </td> 
   <td>获得&nbsp;<code>pair</code>&nbsp;的大小&nbsp;<br> (类模板特化)</td> 
  </tr> 
  <tr> 
   <td> <p><a href="https://zh.cppreference.com/w/cpp/utility/pair/tuple_element" rel="nofollow">std::tuple_element&lt;std::pair&gt;</a></p> <p>(C++11)</p> </td> 
   <td>获得&nbsp;<code>pair</code>&nbsp;中元素的类型&nbsp;<br> (类模板特化)</td> 
  </tr> 
 </tbody> 
</table>

#include <iostream>
    #include<string>
    #include<set>
    #include<algorithm>
    #include<iterator>
    #include<vector>
    #include<tuple>
    #include<utility>
    #include <complex>
    using namespace std;
    
    
    int main()
    {
    	//1.初始化
    	std::pair<int, float> p1;
    	std::cout << "Value-initialized: "
    		<< p1.first << ", " << p1.second << '\n';
    
    	std::pair<int, double> p2(42, 0.123);
    	std::cout << "Initialized with two values: "
    		<< p2.first << ", " << p2.second << '\n';
    
    	std::pair<char, int> p4(p2);
    	std::cout << "Implicitly converted: "
    		<< p4.first << ", " << p4.second << '\n';
    
    	std::pair<std::complex<double>, std::string> p6(
    		std::piecewise_construct,
    		std::forward_as_tuple(0.123, 7.7),
    		std::forward_as_tuple(10, 'a'));
    	std::cout << "Piecewise constructed: "
    		<< p6.first << ", " << p6.second << '\n';
    
    	//使用make_pair
    	pair<int, double> p7 = make_pair(12, 3.4);
    	cout << "p7: " << p7.first << ", " << p7.second << endl;
    
    	p7.first = 666;
    	p7.second = 99.9;
    	cout << "p7: " << p7.first << ", " << p7.second << endl;
    
    	return 0;
    }
    /*
     *
     Value-initialized: 0, 0
    Initialized with two values: 42, 0.123
    Implicitly converted: *, 0
    Piecewise constructed: (0.123,7.7), aaaaaaaaaa
    p7: 12, 3.4
    p7: 666, 99.9
     */

参考链接：

[C++ tuple元组的基本用法(总结)][C_ tuple]

[tuple][std_tuple]

[std_tuple]: https://zh.cppreference.com/w/cpp/utility/tuple
[C_ tuple]: https://blog.csdn.net/sevenjoin/article/details/88420885?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control