std::unwrap_reference, std::unwrap_ref_decay - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<type_traits>`
Definido en el archivo de encabezado `<functional>`
`template< class T > struct unwrap_reference;`	(1)	(desde C++20)
`template< class T > struct unwrap_ref_decay;`	(2)	(desde C++20)

1) Si T es std::reference_wrapper<U> para algún tipo U, proporciona un alias de tipo miembro type que nombra { {tt|U&}}; de lo contrario, proporciona un alias de tipo miembro type que nombra T.

2) Si T es std::reference_wrapper<U> para algún tipo U, ignorando la calificación-cv y la referencialidad, proporciona un alias de tipo miembro type que nombra U&; de lo contrario, proporciona un alias de tipo miembro type que nombra std::decay_t<T>.

El comportamiento de un programa que añade especializaciones para cualquiera de las plantillas definidas en esta página no está definido.

Tipos miembro

Tipo miembro Definición

type

1) U& si T es std::reference_wrapper<U>; T de lo contrario.

2) U& si std::decay_t<T> es std::reference_wrapper<U>; std::decay_t<T> de lo contrario.

Tipos auxiliares

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

Posible implementación

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 que la utilizada por std::make_pair y std::make_tuple.

Macro de Prueba de característica
`__cpp_lib_unwrap_ref`

Ejemplo

#include <cassert>
#include <iostream>
#include <functional>
#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; // de acuerdo, r tiene tipo referencia
        };

        int x = 1;
        reset(x);
        assert(x == 0);

        int y = 2;
        reset(std::ref(y));
        assert(y == 0);
    }
}