Namespaces
Variants

    std::unwrap_reference, std::unwrap_ref_decay

    来自 zh.cppreference.net
     
    C++
     
    工具库
    通用工具
    关系运算符 (C++20 弃用)
    整数比较函数
    (C++20)(C++20)(C++20)    
    (C++20)
    交换 与 类型操作
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    常用词汇类型
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    函数对象
    函数调用
    (C++17)(C++23)
    恒等函数对象
    (C++20)
    透明运算符包装器
    (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)

    旧式绑定器和适配器
    (直至 C++17*)
    (直至 C++17*)
    (直至 C++17*)
    (直至 C++17*)
    (直至 C++17*)  
    (直至 C++17*)
    (直至 C++17*)(直至 C++17*)(直至 C++17*)(直至 C++17*)
    (直至 C++20*)
    (直至 C++20*)
    (直至 C++17*)(直至 C++17*)
    (直至 C++17*)(直至 C++17*)

    (直至 C++17*)
    (直至 C++17*)(直至 C++17*)(直至 C++17*)(直至 C++17*)
    (直至 C++20*)
    (直至 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) 如果 decay 后的 T 是 std::reference_wrapper 的特化，则展开它；否则， T 被 decay。

    如果程序添加了本页描述的任何模板的特化，则行为未定义。

    嵌套类型

    类型 定义
    type

    (1) 若 T 为 std:: reference_wrapper < U > 则为 U& ；否则为 T
    (2) 若 std:: decay_t < T > 为 std:: reference_wrapper < U > 则为 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; // 错误：如果 T 是 reference_wrapper<> 则无法工作
            // 将 T&& 转换为普通类型的 T&
            // 将 T&& 转换为 reference_wrapper<U> 的 U&
            decltype(auto) r = std::unwrap_reference_t<T>(z);
            std::cout << "r: " << r << '\n';
            r = 0; // 正确，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 对象
    (函数模板)