std::unwrap_reference, std::unwrap_ref_decay

Определено в заголовочном файле `<type_traits>`
Определено в заголовочном файле `<functional>`
template< class T > struct unwrap_reference;	(1)	(начиная с C++20)
template< class T > struct unwrap_ref_decay;	(2)	(начиная с C++20)

Разворачивает любой std::reference_wrapper: заменяет std::reference_wrapper<U> на U&.

1) Если T является специализацией std::reference_wrapper, разворачивает его; в противном случае T остается без изменений.

2) Если тип T после удаления ссылок и квалификаторов является специализацией std::reference_wrapper, разворачивает его; в противном случае T приводится к соответствующему типу.

Если программа добавляет специализации для любых шаблонов, описанных на этой странице, поведение не определено.

Вложенные типы

Тип	Определение
`type`	(1) `U&`, если `T` — это std::reference_wrapper<U>; в противном случае — `T` (2) `U&`, если std::decay_t<T> — это std::reference_wrapper<U>; в противном случае — std::decay_t<T>

Вспомогательные типы

template<class T> using unwrap_reference_t = unwrap_reference<T>::type;	(1)	(начиная с C++20)
template<class T> using unwrap_ref_decay_t = unwrap_ref_decay<T>::type;	(2)	(начиная с C++20)

Возможная реализация

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>> {};

Примечания

std::unwrap_ref_decay выполняет то же преобразование, что используется в std::make_pair и std::make_tuple.

Макрос проверки функциональности	Значение	Стандарт	Функциональность
`__cpp_lib_unwrap_ref`	`201811L`	(C++20)	`std::unwrap_ref_decay` и `std::unwrap_reference`

Пример

#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: does not work if T is reference_wrapper<>
            // converts T&& into T& for ordinary types
            // converts T&& into U& for reference_wrapper<U>
            decltype(auto) r = std::unwrap_reference_t<T>(z);
            std::cout << "r: " << r << '\n';
            r = 0; // OK, r has reference type
        };
        
        int x = 1;
        reset(x);
        assert(x == 0);
        
        int y = 2;
        reset(std::ref(y));
        assert(y == 0);
    }
}

Вывод:

r: 1
r: 2

См. также

reference_wrapper (C++11)	Обертка ссылки, удовлетворяющая требованиям CopyConstructible и CopyAssignable (шаблон класса)
make_pair	создает объект `pair` типа, определяемого типами аргументов (шаблон функции)
make_tuple (C++11)	создает объект `tuple` типа, определяемого типами аргументов (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/functional/unwrap_reference