es.cppreference.net

Namespaces

Page

Variants

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

De es.cppreference.net

< cpp | utilidad | pair

pair();	(1)	(constexpr desde C++11) (condicionalmente explícito desde C++11)
pair( const T1& x, const T2& y );	(2)	(constexpr desde C++14) (condicionalmente explícito desde C++11)
template< class U1, class U2 > pair( U1&& x, U2&& y );	(3)	(desde C++11) (constexpr desde C++14) (hasta C++23) (condicionalmente explícito)
template< class U1 = T1, class U2 = T2 > constexpr pair( U1&& x, U2&& y );	(3)		(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)	(constexpr desde C++14) (condicionalmente explícito desde C++11)
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 es construible por defecto implícitamente.

(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 vincularía 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 vincularí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

std::remove_cvref(P) no es una especialización de std::ranges::subrange,
std::is_constructible_v<T1, U1> es true, y
std::is_constructible_v<T2, U2 es 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.

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 se puede usar 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á vinculada a un objeto temporal.

10) El constructor de copia se declara implícitamente(hasta C++11)se define como predeterminado y es constexpr si la copia de ambos elementos satisface los requisitos para funciones constexpr(desde C++11).

11) El constructor de movimiento se define como predeterminado y es constexpr si el movimiento de ambos elementos satisface los requisitos para funciones constexpr.

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

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