Namespaces
Variants

    std::unwrap_reference, std::unwrap_ref_decay

    De es.cppreference.net
     
    C++
    Soporte de compilador
    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 la 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 de tres vías
    (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)
     
    Objetos función
    Invocación de funciones
    (C++17)(C++23)
    Objeto función identidad
    (C++20)
    Envoltorios de operadores transparentes
    (C++14)
    (C++14)
    (C++14)
    (C++14)  
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    Objetos bind y adaptadores antiguos
    (hasta C++17*)
    (hasta C++17*)
    (hasta C++17*)
    (hasta C++17*)
    (hasta C++17*)  
    (hasta C++17*)
    (hasta C++17*)(hasta C++17*)(hasta C++17*)(hasta C++17*)
    (hasta C++20*)
    (hasta C++20*)
    (hasta C++17*)(hasta C++17*)
    (hasta C++17*)(hasta C++17*)

    (hasta C++17*)
    (hasta C++17*)(hasta C++17*)(hasta C++17*)(hasta C++17*)
    (hasta C++20*)
    (hasta C++20*)
     
    Definido en el encabezado <type_traits>
    Definido en el encabezado <functional> 
    template< class T >
struct unwrap_reference;
    		(1) (desde C++20) 
    template< class T >
struct unwrap_ref_decay;
    		(2) (desde C++20)

    Desenvuelve cualquier std::reference_wrapper: cambiando std::reference_wrapper<U> a U&.

    1) Si T es una especialización de std::reference_wrapper, lo desenvuelve; de lo contrario, T permanece igual.
    2) Si el T decaído es una especialización de std::reference_wrapper, lo desenvuelve; de lo contrario, T se decae.

    Si el programa añade especializaciones para cualquiera de las plantillas descritas en esta página, el comportamiento es indefinido.

    Tipos anidados

    Tipo Definición
    type

    (1) U& si T es std:: reference_wrapper < U > ; T en caso contrario
    (2) U& si std:: decay_t < T > es std:: reference_wrapper < U > ; std:: decay_t < T > en caso contrario

    Tipos auxiliares

    template < class T >
    using unwrap_reference_t = unwrap_reference < T > :: type ;
    		(1) (desde C++20)
    template < class T >
    using unwrap_ref_decay_t = unwrap_ref_decay < T > :: type ;
    		(2) (desde C++20)

    Implementación posible 

    template<class T>
struct unwrap_reference { using type = T; };
template<class U>
struct unwrap_reference<std::reference_wrapper<U>> { using type = U&; };
template<class T>
struct unwrap_ref_decay : std::unwrap_reference<std::decay_t<T>> {};

    Notas

    std::unwrap_ref_decay realiza la misma transformación utilizada por std::make_pair y std::make_tuple .

    Macro de prueba de características Valor Std Característica
    __cpp_lib_unwrap_ref 201811L (C++20) std::unwrap_ref_decay y std::unwrap_reference

    Ejemplo

    Ejecutar este código 
    #include <cassert>
#include <functional>
#include <iostream>
#include <type_traits>
int main()
{
    static_assert(std::is_same_v<std::unwrap_reference_t<int>, int>);
    static_assert(std::is_same_v<std::unwrap_reference_t<const int>, const int>);
    static_assert(std::is_same_v<std::unwrap_reference_t<int&>, int&>);
    static_assert(std::is_same_v<std::unwrap_reference_t<int&&>, int&&>);
    static_assert(std::is_same_v<std::unwrap_reference_t<int*>, int*>);
    {
        using T = std::reference_wrapper<int>;
        using X = std::unwrap_reference_t<T>;
        static_assert(std::is_same_v<X, int&>);
    }
    {
        using T = std::reference_wrapper<int&>;
        using X = std::unwrap_reference_t<T>;
        static_assert(std::is_same_v<X, int&>);
    }
    static_assert(std::is_same_v<std::unwrap_ref_decay_t<int>, int>);
    static_assert(std::is_same_v<std::unwrap_ref_decay_t<const int>, int>);
    static_assert(std::is_same_v<std::unwrap_ref_decay_t<const int&>, int>);
    {
        using T = std::reference_wrapper<int&&>;
        using X = std::unwrap_ref_decay_t<T>;
        static_assert(std::is_same_v<X, int&>);
    }
    {
        auto reset = []<typename T>(T&& z)
        {
        //  x = 0; // Error: no funciona si T es reference_wrapper<>
            // convierte T&& en T& para tipos ordinarios
            // convierte T&& en U& para reference_wrapper<U>
            decltype(auto) r = std::unwrap_reference_t<T>(z);
            std::cout << "r: " << r << '\n';
            r = 0; // OK, r tiene tipo referencia
        };
        int x = 1;
        reset(x);
        assert(x == 0);
        int y = 2;
        reset(std::ref(y));
        assert(y == 0);
    }
}

    Salida: 

    r: 1
r: 2

    Véase también

    (C++11)
    		CopyConstructible y CopyAssignable envoltorio de referencia
    (plantilla de clase)
    		crea un objeto pair del tipo determinado por los tipos de argumento
    (plantilla de función)
    (C++11)
    		crea un objeto tuple del tipo definido por los tipos de argumento
    (plantilla de función)