您还将了解pair对象如何封装关键帧及其关联对象，以及pair对象如何表示map容器中的元素。 通常，pair对象可以封装任何类型的对象，并可以生成想要生成的pair对象。 包含数组对象或pair的vector容器。 例如，pair可以封装两个序列容器或两个序列容器的指针。 pair模板在utility头文件中定义，如果不使用贴图而只使用pair对象，则可以包含此头文件。
操作pair
考虑到pair是一种相对简单的模板类型，只有两个公共数据成员first和second。 令人惊讶的是，可以制作各种各样的pair。 我知道如何使用first和second创建对象。
与右值参照参数一样，pair也有许多版本的参照参数，多个版本的右值参照参数可用于将参数隐式转换为所需类型。 例如，使用以下四种不同的方法创建pair对象：
std:string s1 {'test”}，s2{'that'}；
STD : pair : string STD :3360 string my _ pair { S1，s2}；
STD :3360 pair : string STD :3360 string your _ pair { STD :3360 string { ' test ' }，STD3360:string{'that}
STD :3360 pair : string STD :3360 string his _ pair { ' test '，STD33603360string{'that'}；
STD : pair : string STD :3360 string her _ pair { ' test '，' that'}；
第一个pair构造函数复制所有参数的值，第二个移动参数的值，第三个传递第一个参数到string进行隐式转换，最后一个构造函数将这两个参数隐式转换为string对象因为此构造函数具有右值参照参数的版本，所以任何一个或两个模板类型参数都是unique_ptr。
make_pair函数模板是生成并返回pair对象的辅助函数。 可以按如下方式生成上一个代码块的pair对象：
automy _ pair=STD :3360 make _ pair (S1，s2 )；
auto your _ pair=STD :3360 make _ pair (STD :3360 string { ' test ' }，std:string {'that'}；
auto his _ pair=STD : make _ pair : string STD 3360: string (' test '，STD3360:string('that ' ) )；
autoher _ pair=STD : make _ pair : string STD 3360: string (' test '，' that ' )；
前两个语句的函数模板的类型参数由编译器估计。 在最后两句中，类型是明确的。 如果在最后两个语句中忽略模板类型的参数，则对象类型为pair和pair。
pair对象还可以复制或移动构成其的成员变量。 例如：
STD : pair : string STD :3360 string new _ pair { my _ pair }；//复制构造器
STD : pair : string STD : string
old _ pair { STD :3360 make _ pair (STD 33603360 string (his )、STD 3360: string (hers ) ) }；
old_pair由pair类的移动构造函数生成。
另一个pair构造函数可以使用在C 11中引入的此机制通过在适当的位置生成first和second对象来构建pair。 T1和T2构造函数的参数作为tuple参数传递给pair的构造函数。 下一节介绍如何使用tuple对象。 以下是使用pair对象的示例：
STD : pair couple { STD :3360 piecewise _ construct，STD :3360 forward _ as _ tuple (jack '，' Jones )
其中，pair构造函数的第一个参数是utility头文件中定义的piecewise_construct类型的实例。 这是用作标记或标记的空类型。 此piecewise_constmct参数的唯一作用是区分此构造函数的调用与调用具有两个tuple参数(通常用作pair成员变量first和second的值)的构造函数之间的差异
其中，构造函数的第二个和第三个参数指定构建first和second对象的参数集。 forward_as_tuple ()是
tuple 头文件中的函数模板。这里用它的转发参数生成了一个 tuple 引用。不会经常用到这种 pair 的构造函数，但它为不支持拷贝或移动运算的 T1 和 T2 类型提供了在适当位置生成 pair 对象的独特能力。注意，如果参数是一个临时对象，forward_as_tuple() 函数会生成一个右值引用的 tuple。 例如：
int a {1}, b {2};
const auto& c = std::forward_as_tuple(a,b);
这里 c 的类型是 tuple，因此成员变量是引用。但是假设这样写声明的话：
const auto& c = std::forward_as_tuple(1,2);
这里 c 的类型是 tuple，成员变量作为值引用。
如果成员变量可以被复制和移动，pair 对象就支持复制和移动赋值。例如：
std::pair<:string std::string> old_pair; // Default constructor
std::pair<:string std::string> new_pair {std::string{"his"} , std::string{"hers"}};
old_pair = new_pair; // Copy assignment
new_pair = pair<:string std::string>
{std::string{"these"}, std::string{"those"}}; // Move assignment
默认的 pair 构造函数会用它的成员变量，即空的 string 对象来生成 old_pair 这是一个空的字符串对象。第 3 条语句一个成员一个成员地将 new_pair 复制到 old_pair 中。第 4 条语句将作为赋值运算符的右操作数的 pair 对象的成员变量移到 new_pair 中。
当 pair 对象包含不同类型的成员变量时，也可以将一个 pair 对象赋值给另一个 pair 对象，只要作为右操作数的 pair 对象的成员变量可以隐式转换为左操作数的 pair 对象的成员变量的类型。例如：
auto prl = std::make_pair ("these", "those"); // Type pair
std::pair<:string std::string> pr2; // Type pair
pr2 = prl; // OK in this case
prl 成员变量 first 和 second 的类型是 const char*。这个类型可以隐式转换为 string，即 pr2 成员变量的类型，因此可以成功赋值。如果这些类型不能隐式转换，这条赋值语句就无法通过编译。
pair 对象有全套的运算符 ==、!=、、>=。这些运算符都可以正常使用，作为操作数的 pair 对象的类型必须是相同的，它们的成员变量的比较方式也必须相同。相等运算符返回 true，如果左右操作数的成员变量相等的话：
std::pair<:string std::string> new_pair;
new_pair.first = "his";
new_pair.second = "hers";
if (new_pair == std::pair<:string std::string> {"his", ,"hers"})
std::cout << "Equality!n";
new_pair 的成员变量 first 和 second 被赋值为右操作数所包含的字符串。如果 pair 对象是相等的，if 语句会输出一些消息。当两个 pair 对象中的任何一个或两个成员不相等时，!= 比较会返回 true。
对于小于或大于比较，pair 对象的成员变量是按字典顺序比较的。如果 new_pair.first 小于 old_pair.first 的话，表达式 new_pair
std::pair p1 {10, 9};
std::pair p2 {10, 11};
std::pair p3 {11, 9};
std::cout<<:boolalpha p2> p3) << " "<< (p3 > p2) << std::endl;
第一个比较的结果为 true，因为 p1 和 p2 的成员变量 first 相等，p1 的成员变量 second 小于 p2 的成员变量 second。
第二个比较的结果为 false，因为 p1 的 first 小于 p3 的 first。 第三个比较的结果则为 true，因为 p3 的 first 大于 p2 的 first。
pair 的成员函数 swap() 可以和作为参数传入的另一个 pair 对象交换其成员变量 first 和 second。显然，参数必须是相同类型。下面有一个示例：
std::pair p1 {10, 11};
std::pair p2 {11, 9};
p1.swap(p2); // p1={ll,9} p2={10/11}
如果执行两次 swap()，对象恢复成原来的值。