std::pair::pair

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::pair

Funciones miembro

pair::pair

pair::operator=

pair::swap

Funciones no miembro

make_pair

operator==operator!=operator<operator<=operator>operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20)

std::swap

get (C++11)

Guías de deducción(C++17)

Clases auxiliares

tuple_size (C++11)

tuple_element (C++11)

 

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

	(1)
pair();			(hasta C++11)
constexpr pair();			(desde C++11) (conditionally explicit)
		(2)
pair( const T1& x, const T2& y );				(hasta C++11)
pair( const T1& x, const T2& y );				(desde C++11) (hasta C++14) (conditionally explicit)
constexpr pair( const T1& x, const T2& y );				(desde C++14) (conditionally explicit)
			(3)
template< class U1, class U2 > pair( U1&& x, U2&& y );					(desde C++11) (hasta C++14) (conditionally explicit)
template< class U1, class U2 > constexpr pair( U1&& x, U2&& y );					(desde C++14) (hasta C++23) (conditionally explicit)
template< class U1 = T1, class U2 = T2 > constexpr pair( U1&& x, U2&& y );					(desde C++23) (conditionally explicit)
				(4)
template< class U1, class U2 > pair( const pair<U1, U2>& p );						(hasta C++11)
template< class U1, class U2 > pair( const pair<U1, U2>& p );						(desde C++11) (conditionally explicit)
					(5)
template< class U1, class U2 > pair( pair<U1, U2>&& p );							(desde C++11) (hasta C++14) (conditionally explicit)
template< class U1, class U2 > constexpr pair( pair<U1, U2>&& p );							(desde C++14) (conditionally explicit)
						(6)
template< class... Args1, class... Args2 > pair( std::piecewise_construct_t, std::tuple<Args1...> first_args, std::tuple<Args2...> second_args );								(desde C++11) (hasta C++20)
template< class... Args1, class... Args2 > constexpr pair( std::piecewise_construct_t, std::tuple<Args1...> first_args, std::tuple<Args2...> second_args );								(desde C++20)
pair( const pair& p ) = default;							(7)
pair( pair&& p ) = default;							(8)	(desde C++11)

See More

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 sobrecargas si y solo si std::is_default_constructible_v<first_type> y std::is_default_constructible_v<second_type> son true. Este constructor es explicit si y solo si a first_type o second_type no es implícitamente construible por defecto.

(desde C++11)

2) Inicializa first con x y second con y.

Este constructor participa en la resolución de sobrecargas si y solo si std::is_copy_constructible_v<first_type> y std::is_copy_constructible_v<second_type> son true. Este constructor es explicit si y solo si std::is_convertible_v<const first_type&, first_type> es false o std::is_convertible_v<const second_type&, second_type> 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 sobrecargas si y solo si std::is_constructible_v<first_type, U1&&> y std::is_constructible_v<second_type, U2&&> son true.
• Este constructor es explicit si y solo si std::is_convertible_v<U1&&, first_type> es false o std::is_convertible_v<U2&&, second_type> es false.

4) Inicializa first con p.first y second con p.second.

Este constructor participa en la resolución de sobrecargas si y solo si std::is_constructible_v<first_type, const U1&> y std::is_constructible_v<second_type, const U2&> son true. Este constructor es explicit si y solo si std::is_convertible_v<const U1&, first_type> es false o std::is_convertible_v<const U2&, second_type> es false.

(desde C++11)

5) Inicializa first con std::forward<U1>(p.first) y second con std::forward<U2>(p.second).

• Este constructor participa en la resolución de sobrecargas si y solo si std::is_constructible_v<first_type, U1&&> y std::is_constructible_v<second_type, U2&&> son true.
• Este constructor es explicit si y solo si std::is_convertible_v<U1&&, first_type> es false o std::is_convertible_v<U2&&, second_type> es false.

6) 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 que no es por defecto que puede usarse para crear un par de tipos no copiables, no movibles.

7) El constructor de copia está declarado implícitamente (hasta C++11)se marca =default, y es constexpr si la copia de ambos elementos satisface los requerimientos en funciones constexpr (desde C++11).

8) El constructor de movimiento se marca =default, y es constexpr si mover ambos elementos satisface los requerimientos en funciones constexpr}}.

Parámetros

x	-	El valor para cual inicializar el primer elemento de este par.
y	-	El valor para cual inicializar el segundo elemento de este par.
p	-	Un par de valores utilizado para inicializar ambos elementos de este par.
first_args	-	Una tupla de los argumentos del constructor con los cuales inicializar el primer elemento de este par.
second_args	-	Una tupla de los argumentos del constructor con los cuales 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

Ejecuta este código

#include <utility>
#include <string>
#include <complex>
#include <tuple>
#include <iostream>

int main()
{
    auto imprimir = [](auto comentario, auto const& pair) {
        std::cout << comentario << "(" << pair.first << ", " << pair.second << ")\n";
    };

    std::pair<int, float> p1;
    imprimir("(1) Inicializado por valor: ", p1);

    std::pair<int, double> p2{42, 3.1415};
    imprimir("(2) Inicializado con dos valores: ", p2);

    std::pair<char, int> p4{p2};
    imprimir("(4) Convertido implícitamente: ", 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')};
    imprimir("(6) Construido pieza por pieza: ", p6);
}

Posible salida:

(1) Inicializado por valor: (0, 0)
(2) Inicializado con dos valores: (42, 3.1415)
(4) Convertido implícitamente: (*, 3)
(6) Construido pieza por pieza: ((0.123,7.7), aaaaaaaaaa)

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
N4387	C++11	Algunos constructores eran solo implícitos, impidiendo algunos usos.	Los constructores se hicieron condicionalmente explicit.
LWG 2510	C++11	El constructor por defecto era implícito.	Se hizo condicionalmente explicit.

Véase también

make_pair

Crea un objeto de tipo pair, definido por los tipos de los argumentos. (plantilla de función)