C++之std::decay
1.简介
std::decay是C++11之后引进的模板编程工具，它的主要作用是将给定的类型T转换为它的“衰变”类型。这个“衰变”类型是指去除类型T的所有引用、常量和易变性限定符，以及将所有数组和函数转换为对应的指针类型后得到的类型；在头文件
template< class T >
struct decay;2.辅助类
2.1.std::remove_reference和std::remove_reference_t
先看实现：
template
struct remove_reference {
using type = _Ty;
using _Const_thru_ref_type = const _Ty;
};
template
struct remove_reference<_Ty&> { //左值引用
using type = _Ty;
using _Const_thru_ref_type = const _Ty&;
};
template
struct remove_reference<_Ty&&> { //右值引用
using type = _Ty;
using _Const_thru_ref_type = const _Ty&&;
};
template
using remove_reference_t = typename remove_reference<_Ty>::type; 从上面的代码实现来看，它的作用就是擦除类型引用，无论是左值引用还是右值引用，例如，如果_Ty是int&或int&&，那么std::remove_reference_t<_Ty>就是int。示例如下：
#include // std::cout
#include // std::is_same
template
void print_is_same() {
std::cout << std::is_same() << '\n';
}
int main() {
std::cout << std::boolalpha;
print_is_same(); //输出: true
print_is_same(); //输出: false
print_is_same(); //输出: false
print_is_same::type>(); //输出: true
print_is_same::type>(); //输出: true
print_is_same::type>(); //输出: true
} 2.2.std::remove_cv
用于擦除类型的const和volatile限定符，返回的是一个去除了const和volatile限定符的类型，例如，如果T是const int或volatile int，那么std::remove_cv_t就是int。它的实现如下：
template
struct remove_cv { // remove top-level const and volatile qualifiers
using type = _Ty;
template class _Fn>
using _Apply = _Fn<_Ty>; // apply cv-qualifiers from the class template argument to _Fn<_Ty>
};
template
struct remove_cv { //擦除const
using type = _Ty;
template class _Fn>
using _Apply = const _Fn<_Ty>;
};
template
struct remove_cv { //擦除volatile
using type = _Ty;
template class _Fn>
using _Apply = volatile _Fn<_Ty>;
};
template
struct remove_cv { //擦除const volatile
using type = _Ty;
template class _Fn>
using _Apply = const volatile _Fn<_Ty>;
};
template
using remove_cv_t = typename remove_cv<_Ty>::type; 示例如下：
#include
#include
int main() {
typedef std::remove_cv::type type1;
typedef std::remove_cv::type type2;
typedef std::remove_cv::type type3;
typedef std::remove_cv::type type4;
typedef std::remove_cv::type type5;
std::cout << "test1 " << (std::is_same::value
? "passed" : "failed") << '\n';
std::cout << "test2 " << (std::is_same::value
? "passed" : "failed") << '\n';
std::cout << "test3 " << (std::is_same::value
? "passed" : "failed") << '\n';
std::cout << "test4 " << (std::is_same::value
? "passed" : "failed") << '\n';
std::cout << "test5 " << (std::is_same::value
? "passed" : "failed") << '\n';
} 输出：
test1 passed
test2 passed
test3 passed
test4 passed
test5 passed2.3.std::is_array
template< class T >
struct is_array;主要是判断 T 是否为数组类型，如果 T 为数组类型，那么成员常量 value 等于 true。对于其它类型，value 等于 false, 它的实现如下：
template
_INLINE_VAR constexpr bool is_array_v = false; // determine whether type argument is an array
template
_INLINE_VAR constexpr bool is_array_v<_Ty[_Nx]> = true;
template
_INLINE_VAR constexpr bool is_array_v<_Ty[]> = true;
template
struct is_array : bool_constant> {}; 从源码很清晰的看到当输入为数组类型的时候，特例化返回true。示例如下：
#include
#include
#include
class A {};
int main()
{
std::cout << std::boolalpha;
std::cout << std::is_array::value << '\n'; //输出: false
std::cout << std::is_array::value << '\n'; //输出: true
std::cout << std::is_array::value << '\n'; //输出: true
std::cout << std::is_array::value << '\n'; //输出: false
std::cout << std::is_array::value << '\n'; //输出: false
std::cout << std::is_array::value << '\n'; //输出: true
std::cout << std::is_array::value << '\n'; //输出: true
std::cout << std::is_array>::value << '\n'; //输出: false
} 2.4.std::is_function
std::is_function(C++11)用于检查类型是否为函数，注意此处函数类型不包括std::function, lambda, 有重载operator()的类，它的实现如下：
template
_INLINE_VAR constexpr bool is_function_v = // only function types and reference types can't be const qualified
!is_const_v && !is_reference_v<_Ty>;
template
struct is_function : bool_constant> {}; 示例如下：
#include
#include
struct A {
int fun() const&;
};
template
struct PM_traits {};
template
struct PM_traits {
using member_type = U;
};
int f();
int main()
{
std::cout << std::boolalpha;
std::cout << std::is_function::value << '\n'; //输出 : false
std::cout << std::is_function::value << '\n'; //输出 : true
std::cout << std::is_function::value << '\n'; //输出 : true
std::cout << std::is_function::value << '\n'; //输出 : false
using T = PM_traits::member_type; // T 为 int() const&
std::cout << std::is_function::value << '\n'; //输出 : true
} 2.5.std::remove_extent
它的作用是给数组移除一个维度，注意若 T 是多维数组，则只移除第一维。它的实现如下：
template
struct remove_extent { // remove array extent
using type = _Ty;
};
template
struct remove_extent<_Ty[_Ix]> {
using type = _Ty;
};
template
struct remove_extent<_Ty[]> {
using type = _Ty;
};
template
using remove_extent_t = typename remove_extent<_Ty>::type; 多维数组，如果要全部移除维度，则要用std::remove_all_extents, std::remove_all_extents实现如下：
template
struct remove_all_extents { // remove all array extents
using type = _Ty;
};
template
struct remove_all_extents<_Ty[_Ix]> {
using type = typename remove_all_extents<_Ty>::type;
};
template
struct remove_all_extents<_Ty[]> {
using type = typename remove_all_extents<_Ty>::type;
};
template
using remove_all_extents_t = typename remove_all_extents<_Ty>::type; 这里巧妙的借助元编程中模板类的偏特化和递归继承属性: 定义的remove_all_extents偏特化版本继承自身，通过不断地递归继承，直到remove_all_extents
示例如下：
#include
#include
#include
#include
template
typename std::enable_if< std::rank::value == 1 >::type
print_1d(const A& a)
{
copy(a, a+std::extent::value,
std::ostream_iterator::type>(std::cout, " "));
std::cout << '\n';
}
int main()
{
int a[][3] = {{1,2,3},{4,5,6}};
// print_1d(a); // 编译时错误
print_1d(a[1]); //输出： 4 5 6
} 2.6.std::add_pointer
std::add_pointer模板可以把一个类型转换为指针类型，它的实现：
template
struct _Add_pointer { // add pointer (pointer type cannot be formed)
using type = _Ty;
};
template
struct _Add_pointer<_Ty, void_t*>> { // (pointer type can be formed)
using type = remove_reference_t<_Ty>*;
};
template
struct add_pointer {
using type = typename _Add_pointer<_Ty>::type;
};
template
using add_pointer_t = typename _Add_pointer<_Ty>::type; 示例如下：
#include
#include
using namespace std;
int main() {
typedef add_pointer::type ptr; // ptr 是 int* 类型
cout << is_same::value << endl; // 输出 true
return 0;
} 在上面例子中，我们使用add_pointer模板将类型int转换为指针类型int*，并声明了别名ptr。可以看到，使用add_pointer模板可以快速实现类型转换。
2.7.std::conditional
std::conditional模板可以根据条件进行类型选择, 实现如下：
template
struct conditional { // Choose _Ty1 if _Test is true, and _Ty2 otherwise
using type = _Ty1;
};
template
struct conditional {
using type = _Ty2;
};
template
using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type; 示例如下：
#include
#include
#include
int main()
{
typedef std::conditional::type a;
typedef std::conditional::type b;
typedef std::conditional= sizeof(double), int, double>::type c;
std::cout << typeid(a).name() << '\n';
std::cout << typeid(b).name() << '\n';
std::cout << typeid(c).name() << '\n';
} 3.可能实现
介绍完上面的基础知识后，根据std::decay的功能，猜测大致可能的实现如下：
template
struct decay
{
private:
typedef typename std::remove_reference::type U;
public:
typedef typename std::conditional<
std::is_array::value,
typename std::remove_extent::type*,
typename std::conditional<
std::is_function::value,
typename std::add_pointer::type,
typename std::remove_cv::type
>::type
>::type type;
}; 分析步骤：
1) 擦除引用类型。例如 int&和int&& 返回 int
2）如果是数组，返回的就是数组存放的数据类型。例如：int[10] 返回 int
3）如果是函数，返回的就是函数指针。例如：int (int) 返回 int (*)(int)
4) 除2和3之外的其它类型，则擦除const、volatile 或 const volatile。
4.源码分析
根据第3部分讲解的实现流程，在VS2019上是怎么实现上面的功能呢？不隐藏，直接上源码：
template
struct _Select { // Select between aliases that extract either their first or second parameter
template
using _Apply = _Ty1;
};
template <>
struct _Select {
template
using _Apply = _Ty2;
};
template
struct decay { // determines decayed version of _Ty
using _Ty1 = remove_reference_t<_Ty>;
using _Ty2 = typename _Select>::template _Apply, remove_cv<_Ty1>>;
using type = typename _Select>::template _Apply>, _Ty2>::type;
};
template
using decay_t = typename decay<_Ty>::type;
从上面的代码可以看出，把std::conditional替换成了_Select，而_Select的功能和std::conditional是一模一样的，代码的逻辑和第3部分分析的也是一模一样的，在这里就不再过多赘述了。
5.使用
1）在之前我的从C++容器中获取存储数据的类型-CSDN博客中，从容器中获取所存储的数据类型，就用到了std::decay，在函数func获取跟容器中一样数据类型，如下代码：
#include
#include
template
void func(Container& t, const char* pMessage)
{
using TYPE = std::decay;
std::cout << pMessage << boost::typeindex::type_id_with_cvr().pretty_name() << std::endl;
} 调用函数decltype(*t.begin()出来还是引用类型，通过std::decay退变成真正的原始类型Container::value_type。
2）示例如下：
#include
#include
template
struct decay_equiv :
std::is_same::type, U>::type
{};
int main()
{
std::cout << std::boolalpha
<< decay_equiv::value << '\n' /*1*/
<< decay_equiv::value << '\n' /*2*/
<< decay_equiv::value << '\n' /*3*/
<< decay_equiv::value << '\n' /*4*/
<< decay_equiv::value << '\n' /*5*/
<< decay_equiv::value << '\n'; /*6*/
} 上面的代码第1部分是传入int，就是普通类型，传出也是int
上面的代码第2部分是传入int&，通过std::decay擦除左值引用，传出int
上面的代码第3部分是传入int&&，通过std::decay擦除右值引用，传出int
上面的代码第4部分是传入const int&，通过std::decay擦除左值引用，去掉const，传出int
上面的代码第5部分是传入一维数组int[2]，通过std::decay移除一个维度，退化传出int*
上面的代码第6部分是传入函数int(int)，通过std::decay添加指针，传出指向传入函数的指针int(*）(int)。
6.注意事项
1、虽然std::decay可以处理许多类型的转换，但是它不能处理所有的类型。例如，std::decay不能处理类类型，枚举类型，和联合类型。
2、std::decay只能用于模板参数。如果我们尝试在非模板参数上使用std::decay，编译器将会报错。
3、std::decay不能用于消除指针类型。如果我们尝试在指针类型上使用std::decay，std::decay将不会有任何效果。
7.总结
std::decay是我们平时模版编程中使用的比较多的，在实际模板编程或者模板元编程中非常有用，在type_traits源代码里处处可见，实际工作中也会经常用到；上面的介绍只是抛砖引玉，要想真正掌握它，只有的不停地使用，在使用过程中遇到问题，解决问题，才能真正理解它的原理，灵活使用。