close

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

来自cppreference.com
 
C++
 
工具库
通用工具
关系运算符 (C++20 弃用)
 
std::pair
 
pair();
(1) (C++11 起为 constexpr)
(C++11 起条件性 explicit)		 
pair( const T1& x, const T2& y );
(2) (C++11 起条件性 explicit)
(C++14 起为 constexpr)
(3) 
template< class U1, class U2 >
pair( U1&& x, U2&& y );
(C++11 起)
(C++23 前)
(C++14 起为 constexpr)
(条件性 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) 
template< class U1, class U2 >
pair( const pair<U1, U2>& p );
(5) (C++11 起条件性 explicit)
(C++14 起为 constexpr) 
template< class U1, class U2 >
pair( pair<U1, U2>&& p );
(6) (C++14 起为 constexpr)
(C++11 起条件性 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) 
template< class... Args1, class... Args2 >
pair( std::piecewise_construct_t,
      std::tuple<Args1...> first_args,
      std::tuple<Args2...> second_args );
(9) (C++11 起)
(C++20 起为 constexpr)		 
pair( const pair& p ) = default;
(10) 
pair( pair&& p ) = default;
(11) (C++11 起)

构造新的对偶。

1) 默认构造函数。值初始化对偶的两个元素 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::remove_cvref(P) 不是 std::ranges::subrange 的特化，
  • std::is_constructible_v<T1, U1> 是 true，并且
  • std::is_constructible_v<T2, U2> 是 true。
此构造函数当且仅当 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 - 初始化此对偶首元素的值
y - 初始化此对偶第二元素的值
p - 用于初始化此对偶两个元素的值的对偶
u - 用于初始化此对偶两个元素的值的对偶式对象
first_args - 用于初始化此对偶首元素的构造函数实参元组
second_args - 用于初始化此对偶第二元素的构造函数实参元组

异常

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

示例

运行此代码
#include <complex>
#include <iostream>
#include <string>
#include <tuple>
#include <utility>

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...> 的公开成员函数) [编辑]