Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
pair ( ) ;
(1) (constexpr desde C++11)
(condicionalmente explícito desde C++11)
pair ( const T1 & x, const T2 & y ) ;
(2) (condicionalmente explícito desde C++11)
(constexpr desde C++14)
(3)
template < class U1, class U2 >
pair ( U1 && x, U2 && y ) ;
(desde C++11)
(hasta C++23)
(constexpr desde C++14)
(condicionalmente explícito)
template < class U1 = T1, class U2 = T2 >
constexpr pair ( U1 && x, U2 && y ) ;
(desde C++23)
(condicionalmente explícito)
template < class U1, class U2 >
constexpr pair ( pair < U1, U2 > & p ) ;
(4) (desde C++23)
(condicionalmente explícito)
template < class U1, class U2 >
pair ( const pair < U1, U2 > & p ) ;
(5) (condicionalmente explícito desde C++11)
(constexpr desde C++14)
template < class U1, class U2 >
pair ( pair < U1, U2 > && p ) ;
(6) (constexpr desde C++14)
(condicionalmente explícito desde C++11)
template < class U1, class U2 >
constexpr pair ( const pair < U1, U2 > && p ) ;
(7) (desde C++23)
(condicionalmente explícito)
template < pair - like P >
constexpr pair ( P && u ) ;
(8) (desde C++23)
(condicionalmente explícito)
template < class ... Args1 , class ... Args2 >

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

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

Construye un nuevo par.

1) Constructor por defecto. Inicializa por valor ambos elementos del par, first y second .

Este constructor participa en la resolución de sobrecarga si y solo si std:: is_default_constructible_v < T1 > y std:: is_default_constructible_v < T2 > son ambos true .

Este constructor es explicit si y solo si T1 o T2 no son implícitamente construibles por defecto.

(desde C++11)
2) Inicializa first con x y second con y .

Este constructor participa en la resolución de sobrecarga si y solo si std:: is_copy_constructible_v < T1 > y std:: is_copy_constructible_v < T2 > son ambos true .

Este constructor es explicit si y solo si std:: is_convertible_v < const T1 & , T1 > es false o std:: is_convertible_v < const T2 & , T2 > es false .

(desde C++11)
3) Inicializa first con std:: forward < U1 > ( x ) y second con std:: forward < U2 > ( y ) .
Este constructor participa en la resolución de sobrecarga si y solo si std:: is_constructible_v < T1, U1 > y std:: is_constructible_v < T2, U2 > son ambos true .
Este constructor es explicit si y solo si std:: is_convertible_v < U1, T1 > es false o std:: is_convertible_v < U2, T2 > es false .

Este constructor se define como eliminado si la inicialización de first o second podría vincular una referencia a un objeto temporal .

(desde C++23)
4) Inicializa first con p. first y second con p. second .
Este constructor participa en la resolución de sobrecarga si y solo si std:: is_constructible_v < T1, U1 & > y std:: is_constructible_v < T2, U2 & > son ambos true .
Este constructor es explicit si y solo si std:: is_convertible_v < U1 & , T1 > es false o std:: is_convertible_v < U2 & , T2 > es false .
Este constructor se define como eliminado si la inicialización de first o second vincularía una referencia a un objeto temporal.
5) Inicializa first con p. first y second con p. second .

Este constructor participa en la resolución de sobrecarga si y solo si std:: is_constructible_v < T1, const U1 & > y std:: is_constructible_v < T2, const U2 & > son ambos true .

Este constructor es explicit si y solo si std:: is_convertible_v < const U1 & , T1 > es false o std:: is_convertible_v < const U2 & , T2 > es false .

(desde C++11)

Este constructor se define como eliminado si la inicialización de first o second vincularía una referencia a un objeto temporal.

(desde C++23)
6) Inicializa first con std:: forward < U1 > ( p. first ) y second con std:: forward < U2 > ( p. second ) .
Este constructor participa en la resolución de sobrecarga si y solo si std:: is_constructible_v < T1, U1 > y std:: is_constructible_v < T2, U2 > son ambos true .
Este constructor es explicit si y solo si std:: is_convertible_v < U1, T1 > es false o std:: is_convertible_v < U2, T2 > es false .

Este constructor se define como eliminado si la inicialización de first o second enlazaría una referencia a un objeto temporal.

(desde C++23)
7) Inicializa first con std:: forward < const U1 > ( p. first ) y second con std:: forward < const U2 > ( p. second ) .
Este constructor participa en la resolución de sobrecarga si y solo si std:: is_constructible_v < T1, U1 > y std:: is_constructible_v < T2, U2 > son ambos true .
Este constructor es explicit si y solo si std:: is_convertible_v < const U1, T1 > es false o std:: is_convertible_v < const U2, T2 > es false .
Este constructor se define como eliminado si la inicialización de first o second vincularía una referencia a un objeto temporal.
8) Dado u1 como std :: get < 0 > ( std:: forward ( u ) ) y u2 como std :: get < 1 > ( std:: forward ( u ) ) , denota sus tipos como U1 y U2 respectivamente. Inicializa first con u1 y second con u2 .
Este constructor participa en la resolución de sobrecarga si y solo si
Este constructor es explicit si y solo si std:: is_convertible_v < U1, T1 > es false o std:: is_convertible_v < U2, T2 > es false .
Este constructor se define como eliminado si la inicialización de first o second vincularía una referencia a un objeto temporal.
9) Reenvía los elementos de first_args al constructor de first y reenvía los elementos de second_args al constructor de second . Este es el único constructor no predeterminado que puede utilizarse para crear un par de tipos no copiables y no movibles. El programa está mal formado si first o second es una referencia y está vinculado a un objeto temporal.
10) El constructor de copia es declarado implícitamente (hasta C++11) predeterminado, y es constexpr si la copia de ambos elementos satisface los requisitos de las funciones constexpr (desde C++11) .
11) El constructor de movimiento se establece por defecto, y es constexpr si el movimiento de ambos elementos cumple con los requisitos de las funciones constexpr.

Contenidos

Parámetros

x - valor para inicializar el primer elemento de este par
y - valor para inicializar el segundo elemento de este par
p - par de valores utilizado para inicializar ambos elementos de este par
u - pair-like objeto de valores utilizado para inicializar ambos elementos de este par
first_args - tupla de argumentos del constructor para inicializar el primer elemento de este par
second_args - tupla de argumentos del constructor para inicializar el segundo elemento de este par

Excepciones

No lanza excepciones a menos que una de las operaciones especificadas (por ejemplo, el constructor de un elemento) lance.

Ejemplo

Ejecutar este código 
#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) Value-initialized: ", p1);
    std::pair<int, double> p2{42, 3.1415};
    print("(2) Initialized with two values: ", p2);
    std::pair<char, int> p4{p2};
    print("(4) Implicitly converted: ", 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) Piecewise constructed: ", p6);
}

Salida posible: 

(1) Value-initialized: (0, 0)
(2) Initialized with two values: (42, 3.1415)
(4) Implicitly converted: (*, 3)
(8) Piecewise constructed: ((0.123,7.7), aaaaaaaaaa)

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 265 C++98 el constructor por defecto inicializaba por copia first
y second con T1 ( ) y T2 ( ) respectivamente
(por lo tanto requería que T1 y T2 fueran CopyConstructible ) 		first y second
se inicializan por valor
LWG 2510 C++11 el constructor por defecto era implícito hecho condicionalmente-explícito
N4387 C++11 algunos constructores eran solo implícitos, impidiendo ciertos usos constructores hechos condicionalmente-explícitos

Véase también

crea un objeto pair del tipo determinado por los tipos de argumento
(plantilla de función)
construye un nuevo tuple
(función miembro pública de std::tuple<Types...> )