本文介绍: 不难发现,只要传入pair两个类型任意一个默认构造函数explicit的,那么pair的这个默认构造函数就是explicit的,这一点也很好理解。首先是一开始template声明这里加了一个enable_if_t,它用来进行编译检查,即只有第一个模板参数导出结果true时,后面的T才生效,也就是说,如果检查失败,就不存在对应的T,这里template声明就是非法,编译期间就会报错。有点令人意外的是p2,它传入的参数明明是int&,但pair参数类型却是int

pair是STL中提供的一个简单struct用来处理类型不同的一对值,是非常常用的数据结构。这一对值是以public的形式暴露出来的,直接通过firstsecond就能访问我们以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&amp;&amp; _Val1, _Other2&amp;&amp; _Val2) : first(_STD forward<_Other1>(_Val1)), second(_STD forward<_Other2>(_Val2)) {}

    pair(const pair&amp;) = default;
    pair(pair&amp;&amp;)      = default;

    template <class _Other1, class _Other2>
    pair(const pair<_Other1, _Other2>&amp; _Right) : first(_Right.first), second(_Right.second) {}

    template <class _Other1, class _Other2>
    pair(pair<_Other1, _Other2>&amp;&amp; _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&amp; _Val1, _Tuple2&amp; _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_sequencepiecewise_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。

原文地址:https://blog.csdn.net/weixin_45776473/article/details/134615783

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_18301.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注