STL pair源码分析
pair是STL中提供的一个简单的struct，用来处理类型不同的一对值，是非常常用的数据结构。这一对值是以public的形式暴露出来的，直接通过first和second就能访问。我们以MSVC提供的STL源码为例，分析pair的具体实现。在分析过程中可能会对源码进行一定程度地简化。
首先是它存储的数据成员，pair中还记录了这一对值的类型：
template <class _Ty1, class _Ty2>
struct pair { // store a pair of values
using first_type = _Ty1;
using second_type = _Ty2;
_Ty1 first; // the first stored value
_Ty2 second; // the second stored value
};
pair的构造函数提供了以下若干种，实现都比较简单，这里整理出来如下：
template <class _Ty1, class _Ty2>
struct pair {
pair() : first(), second() {}
pair(const _Ty1& _Val1, const _Ty2& _Val2) : first(_Val1), second(_Val2) {}
template <class _Other1, class _Other2>
pair(_Other1&& _Val1, _Other2&& _Val2) : first(_STD forward<_Other1>(_Val1)), second(_STD forward<_Other2>(_Val2)) {}
pair(const pair&) = default;
pair(pair&&) = default;
template <class _Other1, class _Other2>
pair(const pair<_Other1, _Other2>& _Right) : first(_Right.first), second(_Right.second) {}
template <class _Other1, class _Other2>
pair(pair<_Other1, _Other2>&& _Right) : first(_STD forward<_Other1>(_Right.first)), second(_STD forward<_Other2>(_Right.second)) {}
template <class _Tuple1, class _Tuple2, size_t... _Indices1, size_t... _Indices2>
constexpr pair(_Tuple1& _Val1, _Tuple2& _Val2, index_sequence<_Indices1...>, index_sequence<_Indices2...>)
: first(_Tuple_get<_Indices1>(_STD move(_Val1))...), second(_Tuple_get<_Indices2>(_STD move(_Val2))...) {}
template <class... _Types1, class... _Types2>
pair(piecewise_construct_t, tuple<_Types1...> _Val1, tuple<_Types2...> _Val2)
: pair(_Val1, _Val2, index_sequence_for<_Types1...>{}, index_sequence_for<_Types2...>{}) {}
};
通过观察可以得出，pair的构造函数主要分为三类，第一类是传两个值val1，val2进来，pair根据这两个值分别初始化first和second，当传入参数是右值引用时，构造函数需要通过std::forward进行完美转发，保证调用的是first和second的右值引用构造函数；第二类是传另外一个pair对象right进来，构造函数会把right的first和second依次取出，再分别构造自身的first和second，同样这里也需要考虑右值的问题；第三类比较复杂，传入的参数是tuple，tuple类型是C++的多元组，可以包含两个以上的元素。那么这里index_sequence和piecewise_construct_t类型又是什么呢？话不多说，我们来看两个例子，通过例子就能明白了：
#include <iostream>
#include <utility>
#include <tuple>
using namespace std;
struct A
{
int x;
int y;
int z;
A() = default;
A(int x, int y, int z) : x(x), y(y), z(z) {}
};
int main()
{
tuple<int, int, int> t1(1, 2, 3);
tuple<int, int, int> t2(6, 5, 4);
pair<A, A> p1(t1, t2, index_sequence<0, 1, 2>{}, index_sequence<2, 1, 0>{});
pair<A, A> p2(piecewise_construct, t1, t2);
cout << p1.first.x << " " << p1.first.y << " " << p1.first.z << " " << p1.second.x << " " << p1.second.y << " " << p1.second.z << endl;
cout << p2.first.x << " " << p2.first.y << " " << p2.first.z << " " << p2.second.x << " " << p2.second.y << " " << p2.second.z << endl;
return 0;
}
例子的输出结果如下：
1 2 3 4 5 6
1 2 3 6 5 4
到这里就明白了，这两个构造函数是说，不把tuple当作一个类型看待，而是将tuple中的所有元素取出，使用这些元素来构造pair。带有两个index_sequence类型的构造函数，是用这两个sequence来指示，使用tuple里的哪些元素，以及以怎样的顺序，来构造pair的first和second；而带有piecewise_construct_t类型的构造函数其实是前一种的特殊形式，它默认把两个tuple中的所有元素，从头到尾按顺序取出，来构造pair。其实看源码也能发现，这个构造函数的内部实现就是调用了前一个构造函数来完成的。
在STL的实际实现中，这些构造函数的签名并不像前面列出的那么简洁。实际上，STL的每个函数，都希望在编译期间能够尽可能地多做类型检查，并且能确定是否会抛出异常。我们这里以一个构造函数为例，来看看它完整的声明：
template <class _Uty1 = _Ty1, class _Uty2 = _Ty2,
enable_if_t<conjunction_v<is_default_constructible<_Uty1>, is_default_constructible<_Uty2>>, int> = 0>
constexpr explicit(
!conjunction_v<_Is_implicitly_default_constructible<_Uty1>, _Is_implicitly_default_constructible<_Uty2>>)
pair() noexcept(
is_nothrow_default_constructible_v<_Uty1>&& is_nothrow_default_constructible_v<_Uty2>) // strengthened
: first(), second() {}
首先是一开始template的声明，这里加了一个enable_if_t<bool, T>，它用来进行编译检查，即只有第一个模板参数推导出来结果为true时，后面的T才生效，也就是说，如果检查失败，就不存在对应的T，这里的template声明就是非法，编译期间就会报错。
那么它要检查的是什么呢？可以看到是一个conjunction_v<T…>，它挨个对里面的参数进行检查，只有当所有的参数检查通过时，才会返回true。conjunction_v里包含is_default_constructible<_Uty1>和is_default_constructible<_Uty2>这两个参数，从字面意思就能看出，这个template是用来判断某个类型是否有默认构造函数的。那么这下就很清楚了，只有传入pair的两个类型都存在默认构造函数时，这个pair才有默认构造函数，否则编译时就会报错。为了验证这一点，我们写个例子来尝试一下：
#include <iostream>
#include <utility>
#include <tuple>
using namespace std;
struct A
{
A() = default;
A(int x) {}
};
struct B
{
B() = delete;
B(int x) {}
};
int main()
{
pair<A, A> p1; // ok
pair<A, B> p2; // error
pair<A, B> p3(1, 2); // ok
return 0;
}
例子中B类型没有默认构造函数，所以p2编译就会直接失败，而由于A类型和B类型都有接受一个int类型的构造函数，因此p3可以编译成功。
接下来我们发现一个explicit(bool)表达式，它的含义是说如果表达式返回值为true，那么explicit就会生效，也就是说这个默认构造函数是explicit的，必须显式构造不能隐式转换。不难发现，只要传入pair的两个类型任意一个的默认构造函数是explicit的，那么pair的这个默认构造函数就是explicit的，这一点也很好理解。同样我们以例子进行佐证：
#include <iostream>
#include <utility>
#include <tuple>
using namespace std;
struct A
{
A() = default;
};
struct B
{
explicit B() = default;
};
int main()
{
pair<A, A> p1 = {}; // ok
pair<A, B> p2 = {}; // error
return 0;
}
用MSVC编译时，报错信息还贴心地告诉了我们这个构造函数是explicit的：
test.cpp(20): error C2512: 'std::pair<A,B>': no appropriate default constructor available
test.cpp(20): note: Constructor for struct 'std::pair<A,B>' is declared 'explicit'
最后就是noexcept声明了，同理，只有当pair的两个类型默认构造函数都不抛出异常时，它才不会抛出异常。
有了构造函数之后，就要有与之匹配的赋值操作，pair重载的赋值操作符大概也有以下几种：
template <class _Ty1, class _Ty2>
struct pair {
pair& operator=(const volatile pair&) = delete;
template <class _Myself = pair>
pair& operator=(_Identity_t<const _Myself&> _Right) {
first = _Right.first;
second = _Right.second;
return *this;
}
template <class _Myself = pair>
pair& operator=(_Identity_t<_Myself&&> _Right) {
first = _STD forward<_Ty1>(_Right.first);
second = _STD forward<_Ty2>(_Right.second);
return *this;
}
template <class _Other1, class _Other2>
pair& operator=(const pair<_Other1, _Other2>& _Right) {
first = _Right.first;
second = _Right.second;
return *this;
}
template <class _Other1, class _Other2>
pair& operator=(pair<_Other1, _Other2>&& _Right) {
first = _STD forward<_Other1>(_Right.first);
second = _STD forward<_Other2>(_Right.second);
return *this;
}
};
基本和构造函数一一对应，这里就不再赘述了。pair还提供了swap操作，相同类型和不同类型的两个pair都可以进行swap，交互彼此的值：
template <class _Ty1, class _Ty2>
struct pair {
void swap(pair& _Right) {
using _STD swap;
if (this != _STD addressof(_Right)) {
swap(first, _Right.first); // intentional ADL
swap(second, _Right.second); // intentional ADL
}
}
};
template <class _Ty1, class _Ty2>
void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right) {
_Left.swap(_Right);
}
swap不同类型的pair，需要把后一个pair类型转换为前一个类型。swap内部实现也很简单，就是分别调用每个类型的swap，ADL机制保证了这一点。
pair类型还提供了比较机制，它会首先拿第一个类型进行比较，如果第一个元素不相等，那么比较结果就是最终的结果，如果相等才会比较第二个元素。这意味着只有当两个元素都相等时，两个pair对象才会视为相等。
template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
constexpr bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
return _Left.first == _Right.first && _Left.second == _Right.second;
}
template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
constexpr common_comparison_category_t<_Synth_three_way_result<_Ty1, _Uty1>,
_Synth_three_way_result<_Ty2, _Uty2>>
operator<=>(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
if (auto _Result = _Synth_three_way{}(_Left.first, _Right.first); _Result != 0) {
return _Result;
}
return _Synth_three_way{}(_Left.second, _Right.second);
}
C++ 20提出了spaceship <=> 操作符，可以不再写重复的比较代码了，<=>操作符返回的对象有以下的性质：
当左操作数 < 右操作数时，对象 < 0；
当左操作数 > 右操作数时，对象 > 0；
当左操作数 = 右操作数时，对象 = 0。
还是以一个例子来验证：
#include <iostream>
#include <utility>
#include <tuple>
using namespace std;
int main()
{
pair<int, int> p1(1, 2);
pair<int, int> p2(3, 4);
auto comp = (p1 <=> p2);
if(comp < 0)
{
cout << "p1 < p2" << endl;
}
else if(comp > 0)
{
cout << "p1 > p2" << endl;
}
else
{
cout << "p1 == p2" << endl;
}
return 0;
}
记得要用C++20标准编译哦，不然编译就过不去了，运行结果如下：
>cl test.cpp /std:c++20
>test.exe
p1 < p2
最后，pair还支持便捷函数make_pair构造出对象。注意如果两个参数类型是reference_wrapper，则需要取它们的引用类型作为pair的类型，make_pair本身的实现很简单，就是调用一下pair的构造函数即可。
template <class _Ty>
struct _Unrefwrap_helper { // leave unchanged if not a reference_wrapper
using type = _Ty;
};
template <class _Ty>
struct _Unrefwrap_helper<reference_wrapper<_Ty>> { // make a reference from a reference_wrapper
using type = _Ty&;
};
// decay, then unwrap a reference_wrapper
template <class _Ty>
using _Unrefwrap_t = typename _Unrefwrap_helper<decay_t<_Ty>>::type;
_EXPORT_STD template <class _Ty1, class _Ty2>
_NODISCARD constexpr pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>> make_pair(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
is_nothrow_constructible_v<_Unrefwrap_t<_Ty1>, _Ty1>&&
is_nothrow_constructible_v<_Unrefwrap_t<_Ty2>, _Ty2>) /* strengthened */ {
// return pair composed from arguments
using _Mypair = pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>>;
return _Mypair(_STD forward<_Ty1>(_Val1), _STD forward<_Ty2>(_Val2));
}
看个例子，就能明白这里特殊处理reference_wrapper的作用了：
#include <iostream>
#include <utility>
using namespace std;
template<typename T>
void f(T&& x)
{
}
int main()
{
int x = 1;
auto p1 = make_pair(x, x);
p1.first = 3;
cout << "x " << x << endl;
int& y = x;
auto p2 = make_pair(y, y);
p2.first = 5;
cout << "x " << x << endl;
auto p3 = make_pair(ref(x), ref(x));
p3.first = 7;
cout << "x " << x << endl;
pair<int&, int&> p4(y, y);
p4.first = 9;
cout << "x " << x << endl;
return 0;
}
例子的输出结果如下：
x 1
x 1
x 7
x 9
有点令人意外的是p2，它传入的参数明明是int&，但pair的参数类型却是int。这是因为make_pair返回的参数类型是_Unrefwrap_t，而它会先调用一次decay_t把引用类型给摘掉，虽然一开始_Ty1和_Ty2都会被推导为int&，但是经过decay_t之后它们就退化成了int，传给了pair。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
