命名空间
变体
操作

std::unwrap_reference, std::unwrap_ref_decay

来自 cppreference.com
< cpp‎ | utility‎ | functional
 
 
实用程序库
语言支持
类型支持 (基本类型, RTTI)
库特性测试宏 (C++20)
动态内存管理
程序实用程序
协程支持 (C++20)
可变参数函数
调试支持
(C++26)
三方比较
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
通用实用程序
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中已弃用)
整数比较函数
(C++20)(C++20)(C++20)   
(C++20)
交换类型操作
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
通用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
基本字符串转换
(C++17)
(C++17)

 
函数对象
函数调用
(C++17)(C++23)
身份函数对象
(C++20)
引用包装器
(C++11)(C++11)
unwrap_referenceunwrap_ref_decay
(C++20)(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++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 起)
1) 如果 Tstd::reference_wrapper<U> 对于某个类型 U,提供一个成员类型别名 type,命名为 U&; 否则,提供一个成员类型别名 type,命名为 T
2) 如果 Tstd::reference_wrapper<U> 对于某个类型 U,忽略 cv 限定和引用性,提供一个成员类型别名 type,命名为 U&; 否则,提供一个成员类型别名 type,命名为 std::decay_t<T>.

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

内容

[编辑] 成员类型

名称 定义
type

(1) U& 如果 Tstd::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_pairstd::make_tuple 使用的相同的转换。

特性测试 Std 特性
__cpp_lib_unwrap_ref 201811L (C++20) std::unwrap_ref_decaystd::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

[编辑] 参见

可复制构造可复制赋值 引用包装器
(类模板) [编辑]
创建一个类型为 pair 的对象,类型由参数类型决定。
(函数模板) [编辑]
创建一个类型由参数类型定义的 tuple 对象。
(函数模板) [编辑]