《C++11标准库》5.1.1Pair

class pair 可将两个 value视为一个单元。C++标准库内多处用到了这个 class 。尤其是容器 map、multimap、unordered_map和 unordered_multimap就是使用 pair 来管理其以 key/value pair形式存在的元素。任何函数如果需要返回两个 value，也需要用到 pair，例如 minmax()。

pair的结构定义于<utility>，且提供如下所示各种操作：

原则上你可以对pair<>执行 creat，copy/assign/swap及compare操作。此外它还提供first_type和second_type类型定义式，用来表示第一 value和第二 value的类型。

元素访问

为了让程序能够处理pair的两个值，它提供了“直接访问对应数据成员”的能力。事实上由于它是个 struct而不是class，以至于所有成员都是public：

namespace std
{
	template<typename T1,typename T2>
	struct pair
	{
		T1 first;
		T2 second;
	};
}

如果要实现一个泛型函数模板，用以将一个 value pair写入一个stream内，你必须：

template<typename T1, typename T2>
std::ostream& operator<<(std::ostream& strm, const std::pair<T1, T2>& p)
{
	return strm << "[" << p.first << "," << p.second << "]";
}

另外，自C++11起，你可以对pair使用一份tuple-like接口。因此，你可以使用tuple_size<>::value获得元素个数，使用 tuple_element<>::type获得某指定元素的类型，也可以使用get()获得first或second； 

typedef std::pair<int, float> InFloatPair;
InFloatPair p(42, 3.14);
int main()
{
	std::get<0>(p);// p第一个元素。
	std::get<1>(p);// p第二个元素。
	std::tuple_size<InFloatPair>::value;//获取pair元素个数
	std::tuple_element<0, InFloatPair>::type;//获取队组中第一个元素的类型。
}

 构造函数与赋值

Default 构造函数生成一个 pair 时，以两个“被 default构造函数个别初始化”的元素作为初值。根据语言规则，基础类型（如 int）的default构造函数也可以引起适当的初始化行为。

例如：

std::pair<int, float>p;

上述形式就是以 int()和 float()来初始化p。这两个构造函数都穿回 0值。

Copy构造函数同时存在两个版本，版本1接受相同类型的pair，版本2是个member template，在“构造函数需要隐式类型转换”时被调用。如果 pair对象被复制，调用的是被隐式合成的那个copy构造函数。例如：

void f(std::pair<int, const char*>);
void g(std::pair<const int, std::string>);
void foo()
{
	std::pair<int, const char*> p(42, "hello");
	f(p);//直接调用
	g(p);//具有const char*到 string 的隐式类型转换
}

自C++11开始，如果 pair<>用到了某个类型而该类型只有一个 非常数（nonconstant）的拷贝构造函数，将不在编译成功：

逐块式构造

Class pair<>提供了三个构造函数，用以初始化 first和 second成员：

namespace std
{
	template<typename T1,typename T2>
	struct pair
	{
		pair(const T1& x, const T2& y);
		template<typename U, typename V>pair(U&& x, V&& y);
		template<typename...Args1,typename...Args2>
		pair(piecewise_construct_t, tuple<Args1...>first_args, tuple<Args2...>second_args);
	};
}

 前两个函数提供的是一般行为：传递一个实参给 first，另一个实参给 second ，并且涵盖对移动语义和隐式类型转换的支持。

第三个构造函数，允许传递两个 tuple的对象，将其元素传递给 first 和 second的构造函数。为了强迫执行这样的行为，你必须传递 std::piecewise_construct作为额外的第一实参。

例如：

class Foo
{
public:
	Foo(tuple<int, float>)
	{
		cout << "调用：Foo(tuple<int, float>)" << endl;
	}
	template<typename...Arge>
	Foo(Arge...arge)
	{
		cout << "调用：template<typename...Arge> Foo(Arge...arge)" << endl;
	}
};
int main()
{
	int a = 42;
	tuple<int, float> t(1, 2.22);
	pair<int, Foo> p1(a, t);
	pair<int, Foo>p2(piecewise_construct, make_tuple(a), t);
	return 0;
}

程序运行结果：

 只有当std::piecewise_construct被当作第一实参，class Foo才会被迫使用那个“接受tuple的元素而不是接受 tuple这个整体“的构造函数。如果提供 Foo::Foo(int,float)构造函数的话，那么将会调用这个构造函数。

对于带有std::piecewise_construct参数的构造函数，只有当两个实参都是 tuple 是才会被导致这个行为。

便携函数 make_pair()

Template 函数 make_pair()使你无须写出类型就能生成一个 pair对象。例如：

std::pair<int, string>(42, "0");

可以写成下面示例：

std::make_pair(42, "0");

自C++11起， class pair需要应付 移动语义，所以其对 make_pair()的声明如下：

namespace std {
	template<template T1,template T2>
	pair<V1, V2>make_pair(T1&& x, T2&& y);
}

对于这样的模板，其中返回值的细节和它们的类型V1，V2，取决于x和y的类型。且如果make_pair()可使用移动语义，那么优先使用移动语义，否则使用复制语义。