Namespaces
Variants

    std::make_pair

    De es.cppreference.net
     
    C++
    Soporte de compiladores
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades 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 soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación tripartita
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    std::pair
     
    Definido en el encabezado <utility> 
    template< class T1, class T2 >
std::pair<T1, T2> make_pair( T1 x, T2 y );
    		(hasta C++11) 
    template< class T1, class T2 >
std::pair</*V1*/, /*V2*/> make_pair( T1&& x, T2&& y );
    		(desde C++11)
    (hasta C++20)
    (constexpr desde C++14)    		 
    template< class T1, class T2 >
constexpr std::pair<std::unwrap_ref_decay_t<T1>,
                    std::unwrap_ref_decay_t<T2>>
    make_pair( T1&& x, T2&& y );
    		(desde C++20)

    Crea un objeto std::pair, deduciendo el tipo destino a partir de los tipos de los argumentos.

    Dados los tipos std::decay<T1>::type como U1 y std::decay<T2>::type como U2, los tipos /*V1*/ y /*V2*/ se definen de la siguiente manera:

    • Si U1 es std::reference_wrapper<X>, entonces /*V1*/ es X&; de lo contrario, /*V1*/ es U1.
    • Si U2 es std::reference_wrapper<Y>, entonces /*V2*/ es Y&; de lo contrario, /*V2*/ es U2.
    		 (desde C++11)
    (hasta C++20)

    Parámetros

    x, y - los valores para construir el par

    Valor de retorno

    std:: pair < T1, T2 > ( x, y )

    		(hasta C++11)

    std:: pair < /*V1*/ , /*V2*/ > ( std:: forward < T1 > ( x ) , std:: forward < T2 > ( y ) )

    		(desde C++11)
    (hasta C++20)

    std:: pair < std:: unwrap_ref_decay_t < T1 > , std:: unwrap_ref_decay_t < T2 >>
    ( std:: forward < T1 > ( x ) , std:: forward < T2 > ( y ) )

    		(desde C++20)

    Ejemplo

    Ejecutar este código 
    #include <functional>
#include <iostream>
#include <utility>
int main()
{
    int n = 1;
    int a[5] = {1, 2, 3, 4, 5};
    // construir un par a partir de dos enteros
    auto p1 = std::make_pair(n, a[1]);
    std::cout << "El valor de p1 es "
              << '(' << p1.first << ", " << p1.second << ")\n";
    // construir un par a partir de una referencia a int y un array (degradado a puntero)
    auto p2 = std::make_pair(std::ref(n), a);
    n = 7;
    std::cout << "El valor de p2 es "
              << '(' << p2.first << ", " << *(p2.second + 2) << ")\n";
}

    Salida: 

    El valor de p1 es (1, 2)
El valor de p2 es (7, 3)

    Informes de defectos

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

    DR Applied to Behavior as published Correct behavior
    LWG 181 C++98 los tipos de parámetros eran tipos de referencia constante,
    lo que hacía imposible pasar arrays     		se cambiaron estos
    tipos a tipos de valor