C++系列22:decay_t

类型转换工具，用于移除类型的引用和 cv（const 和 volatile） 限定符，并将数组或函数类型转换为指针类型。

得到衰减后的类型

#include <iostream>
#include <type_traits>

template <typename T>
void printType() {
    // 使用 std::decay_t 获取衰减后的类型
    using DecayType = std::decay_t<T>;
    std::cout << "Original type: " << typeid(T).name() << std::endl;
    std::cout << "Decayed type: " << typeid(DecayType).name() << std::endl;
}

int main() {
    printType<int>();            // 原始类型是 int，衰减后的类型也是 int
    printType<int&>();           // 原始类型是 int&，衰减后的类型是 int
    printType<const int[]>();    // 原始类型是 const int[]，衰减后的类型是 const int*
    printType<void(int)>();      // 原始类型是 void(int)，衰减后的类型是 void(*)(int)
    
    return 0;
}
数组转指针： 如果输入类型是数组，std::decay_t 会将数组转换为指向数组元素类型的指针。

函数转函数指针： 如果输入类型是函数类型，std::decay_t 会将其转换为相应的函数指针类型。

#include <iostream>
#include <type_traits>
using namespace std;

typedef decay<int>::type         A;                                     // A is int
typedef decay<int &>::type       B;                                     // B is int
typedef decay<int &&>::type      C;                                     // C is int
typedef decay<const int &>::type D;                                     // D is int
typedef decay<int[2]>::type      E;                                     // E is int *
typedef decay<int(int)>::type    F;                                     // F is int(*)(int)

int main(){
    cout << boolalpha;
    cout << is_same<int, A>::value         << endl;                     // true
    cout << is_same<int, B>::value         << endl;                     // true
    cout << is_same<int, C>::value         << endl;                     // true
    cout << is_same<int, D>::value         << endl;                     // true
    cout << is_same<int *, E>::value       << endl;                     // true
    cout << is_same<int(int), F>::value    << endl;                     // false
    cout << is_same<int(*)(int), F>::value << endl;                     // true

    return 1;
}

#include <iostream>
#include <type_traits>
using namespace std;

class MyClass {};

typedef decay<MyClass>::type         A;                                 // A is MyClass
typedef decay<MyClass &>::type       B;                                 // B is MyClass
typedef decay<MyClass &&>::type      C;                                 // C is MyClass
typedef decay<const MyClass &>::type D;                                 // D is MyClass
typedef decay<MyClass[2]>::type      E;                                 // E is MyClass *
typedef decay<MyClass *>::type       F;                                 // E is MyClass *
typedef decay<MyClass *[2]>::type    G;                                 // G is MyClass **
typedef decay<MyClass **>::type      H;                                 // H is MyClass **

int main(){
    cout << boolalpha;
    cout << is_same<MyClass, A>::value    << endl;                      // true
    cout << is_same<MyClass, B>::value    << endl;                      // true
    cout << is_same<MyClass, C>::value    << endl;                      // true
    cout << is_same<MyClass, D>::value    << endl;                      // true
    cout << is_same<MyClass *, E>::value  << endl;                      // true
    cout << is_same<MyClass *, F>::value  << endl;                      // true
    cout << is_same<MyClass **, G>::value << endl;                      // true
    cout << is_same<MyClass **, H>::value << endl;                      // true

    return 1;
}