Namespaces
Variants

std:: unwrap_reference, std:: unwrap_ref_decay

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Reference wrappers
(C++11)
(C++11) (C++11)
unwrap_reference unwrap_ref_decay
(C++20) (C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
Определено в заголовке <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>> {};
**Примечание:** Весь код C++ внутри тегов ` 
` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Примечания

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; // Ошибка: не работает, если T является reference_wrapper<>
            // преобразует T&& в T& для обычных типов
            // преобразует T&& в U& для reference_wrapper<U>
            decltype(auto) r = std::unwrap_reference_t<T>(z);
            std::cout << "r: " << r << '\n';
            r = 0; // OK, r имеет ссылочный тип
        };
        int x = 1;
        reset(x);
        assert(x == 0);
        int y = 2;
        reset(std::ref(y));
        assert(y == 0);
    }
}

Вывод: 

r: 1
r: 2

Смотрите также

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