C++ 11 pair

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构造函数。例如：

上述形式就是以 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);

return0;

}

只有当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()可使用移动语义，那么优先使用移动语义，否则使用复制语义。