std::pair<T1,T2>::pair

来自cppreference.com
< cpp‎ | utility‎ | pair
 
C++
 
工具库
通用工具
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中弃用)
整数比较函数
(C++20)(C++20)(C++20)
(C++20)
swap 与类型运算
(C++20)
(C++14)
(C++11)
(C++23)
(C++11)
(C++23)
(C++11)
(C++11)
(C++17)
常用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++11)
(C++17)
(C++17)
(C++23)
初等字符串转换
(C++17)
(C++17)
(C++17)
 
std::pair
成员函数
pair::pair
(C++11)
非成员函数
(C++20 前)(C++20 前)(C++20 前)(C++20 前)(C++20 前)(C++20)
(C++11)
(C++11)
推导指引(C++17)
辅助类
(C++11)
(C++11)
(C++23)
(C++23)
 
(1)
pair();
 (C++11 前)
constexpr pair();
 (C++11 起)
(条件性 explicit)
(2)
pair( const T1& x, const T2& y );
 (C++11 前)
pair( const T1& x, const T2& y );
 (C++11 起)
(C++14 前)
(条件性 explicit)
constexpr pair( const T1& x, const T2& y );
 (C++14 起)
(条件性 explicit)
(3)
template< class U1, class U2 >
pair( U1&& x, U2&& y );
 (C++11 起)
(C++14 前)
(条件性 explicit)
template< class U1, class U2 >
constexpr pair( U1&& x, U2&& y );
 (C++14 起)
(C++23 前)
(条件性 explicit)
template< class U1 = T1, class U2 = T2 >
constexpr pair( U1&& x, U2&& y );
 (C++23 起)
(条件性 explicit)
template< class U1, class U2 >
constexpr pair( pair<U1, U2>& p );
 (4) (C++23 起)
(条件性 explicit)
(5)
template< class U1, class U2 >
pair( const pair<U1, U2>& p );
 (C++11 前)
template< class U1, class U2 >
pair( const pair<U1, U2>& p );
 (C++11 起)
(C++14 前)
(条件性 explicit)
template< class U1, class U2 >
constexpr pair( const pair<U1, U2>& p );
 (C++14 起)
(条件性 explicit)
(6)
template< class U1, class U2 >
pair( pair<U1, U2>&& p );
 (C++11 起)
(C++14 前)
(条件性 explicit)
template< class U1, class U2 >
constexpr pair( pair<U1, U2>&& p );
 (C++14 起)
(条件性 explicit)
template< class U1, class U2 >
constexpr pair( const pair<U1, U2>&& p );
 (7) (C++23 起)
(条件性 explicit)
template< pair-like P >
constexpr pair ( P&& u );
 (8) (C++23 起)
(条件性 explicit)
(9)
template< class... Args1, class... Args2 >

pair( std::piecewise_construct_t,
      std::tuple<Args1...> first_args,

      std::tuple<Args2...> second_args );
 (C++11 起)
(C++20 前)
template< class... Args1, class... Args2 >

constexpr pair( std::piecewise_construct_t,
                std::tuple<Args1...> first_args,

                std::tuple<Args2...> second_args );
 (C++20 起)
pair( const pair& p ) = default;
 (10)
pair( pair&& p ) = default;
 (11) (C++11 起)

构造新的 pair。

1) 默认构造函数。值初始化 pair 的两个元素 first 和 second。

此构造函数只有在 std::is_default_constructible_v<T1> 与 std::is_default_constructible_v<T2> 都是 true 的情况下才会参与重载决议。

此构造函数只有在 T1 或 T2 不可隐式默认构造的情况下才是 explicit 的。

(C++11 起)
2) 以 x 初始化 first 并以 y 初始化 second。

此构造函数只有在 std::is_copy_constructible_v<T1> 与 std::is_copy_constructible_v<T2> 都是 true 的情况下才会参与重载决议。

此构造函数只有在 std::is_convertible_v<const T1&, T1> 是 false 或 std::is_convertible_v<const T2&, T2> 是 false 的情况下才是 explicit 的。

(C++11 起)
3) 以 std::forward<U1>(x) 初始化 first 并以 std::forward<U2>(y) 初始化 second。
此构造函数只有在 std::is_constructible_v<T1, U1> 和 std::is_constructible_v<T2, U2> 都是 true 的情况下才会参与重载决议。
此构造函数只有在 std::is_convertible_v<U1, T1> 是 false 或 std::is_convertible_v<U2, T2> 是 false 的情况下才是 explicit 的。

如果 first 或 second 的初始化会绑定引用到临时对象，那么此构造函数会定义为被弃置。

(C++23 起)
4) 以 p.first 初始化 first 并以 p.second 初始化 second。
此构造函数只有在 std::is_constructible_v<T1, U1&> 和 std::is_constructible_v<T2, U2&> 都是 true 的情况下才会参与重载决议。
此构造函数只有在 std::is_convertible_v<U1&, T1> 是 false 或 std::is_convertible_v<U2&, T2> 是 false 的情况下才是 explicit 的。
如果 first 或 second 的初始化会绑定引用到临时对象，那么此构造函数会定义为被弃置。
5) 以 p.first 初始化 first 并以 p.second 初始化 second。

此构造函数只有在 std::is_constructible_v<T1, const U1&> 和 std::is_constructible_v<T2, const U2&> 都是 true 的情况下才会参与重载决议。

此构造函数只有在 std::is_convertible_v<const U1&, T1> 是 false 或 std::is_convertible_v<const U2&, T2> 是 false 的情况下才是 explicit 的。

(C++11 起)

如果 first 或 second 的初始化会绑定引用到临时对象，那么此构造函数会定义为被弃置。

(C++23 起)
6) 以 std::forward<U1>(p.first) 初始化 first 并以 std::forward<U2>(p.second) 初始化 second。
此构造函数只有在 std::is_constructible_v<T1, U1> 和 std::is_constructible_v<T2, U2> 都是 true 的情况下才会参与重载决议。
此构造函数只有在 std::is_convertible_v<U1, T1> 是 false 或 std::is_convertible_v<U2, T2> 是 false 的情况下才是 explicit 的。

如果 first 或 second 的初始化会绑定引用到临时对象，那么此构造函数会定义为被弃置。

(C++23 起)
7) 以 std::forward<const U1>(p.first) 初始化 first 并以 std::forward<const U2>(p.second) 初始化 second。
此构造函数只有在 std::is_constructible_v<T1, const U1> 和 std::is_constructible_v<T2, const U2> 都是 true 的情况下才会参与重载决议。
此构造函数只有在 std::is_convertible_v<const U1, T1> 是 false 或 std::is_convertible_v<const U2, T2> 是 false 的情况下才是 explicit 的。
如果 first 或 second 的初始化会绑定引用到临时对象，那么此构造函数会定义为被弃置。
8) 给定 u1 为 std::get<0>(std::forward(u))，u2 为 std::get<1>(std::forward(u))，并分别以 U1 和 U2 表示它们的类型。以 u1 初始化 first 并以 u2 初始化 second。
此构造函数只有在满足以下所有条件的情况下才会参与重载决议：
此构造函数只有在 std::is_convertible_v<U1, T1> 是 false 或 std::is_convertible_v<U2, T2> 是 false 的情况下才是 explicit 的。
如果 first 或 second 的初始化会绑定引用到临时对象，那么此构造函数会定义为被弃置。
9) 转发 first_args 的元素到 first 的构造函数并转发 second_args 的元素到 second 的构造函数。除了默认构造函数外，只有该构造函数能用于构造不可复制不可移动类型的 pair。如果 first 或 second 是引用且被绑定到临时对象，那么程序非良构。
10) 复制构造函数是隐式声明的 (C++11 前)默认的，且它在两个元素的复制满足 constexpr 函数的要求是 constexpr 的 (C++11 起)。
10) 移动构造函数是默认的，且它在两个元素的移动满足 constexpr 函数的要求时是 constexpr 的。

参数

x - 初始化此 pair 首元素的值
y - 初始化此 pair 第二元素的值
p - 用于初始化此 pair 两个元素的值的 pair
u - 用于初始化此 pair 两个元素的值的 pair-like 对象
first_args - 初始化此 pair 首元素的构造函数参数的 tuple
second_args - 初始化此 pair 第二元素的构造函数参数的 tuple

异常

不抛异常，除非指定操作之一（如元素的构造）抛出。

示例

运行此代码
#include <utility>
#include <string>
#include <complex>
#include <tuple>
#include <iostream>
 
int main()
{
    auto print = [](auto rem, auto const& pair)
    {
        std::cout << rem << "(" << pair.first << ", " << pair.second << ")\n";
    };
 
    std::pair<int, float> p1;
    print("(1) 值初始化：", p1);
 
    std::pair<int, double> p2{42, 3.1415};
    print("(2) 以两个值进行初始化：", p2);
 
    std::pair<char, int> p4{p2};
    print("(4) 隐式转换：", p4);
 
    std::pair<std::complex<double>, std::string> p6
    {std::piecewise_construct, std::forward_as_tuple(0.123, 7.7),
        std::forward_as_tuple(10, 'a')};
    print("(8) 逐段构造：", p6);
}

可能的输出： 

(1) 值初始化：(0, 0)
(2) 以两个值进行初始化：(42, 3.1415)
(4) 隐式转换：(*, 3)
(8) 逐段构造：((0.123,7.7), aaaaaaaaaa)

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 265 C++98 默认构造函数分别以 T1() 和 T2() 复制初始化 first 和
second（因此 T1 和 T2 需要可复制构造 (CopyConstructible) ） 		first 和 second
会被值初始化
LWG 2510 C++11 默认构造函数不是 explicit 的 改成是条件性 explicit 的
N4387 C++11 某些构造函数是 explicit 的，这会阻止有用的行为 将大多数构造函数改成是条件性 explicit 的

参阅

 创建一个 pair 对象，其类型根据各实参类型定义
(函数模板)
构造新的 tuple
(std::tuple<Types...> 的公开成员函数)
来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/utility/pair/pair&oldid=77804”