第17课 类型萃取（1）_基本的type_traits

1. type_traits类型萃取

（1）type_traits通过定义一些结构体或类，并利用模板类特化和偏特化的能力，给类型赋予一些特性，这些特性根据类型的不同而异。在程序设计中可以使用这些traits来判断一个类型的一些特性，引发C++的函数重载机制，实现同一种操作因类型不同而异的效果。

（2）type_traits提供了丰富的编译期计算、查询、判断、转换和选择的帮助类。

（3）type_traits的类型选择功能，在一定程序上可以消除冗长的switch-cast或if-else的语句。提高代码可维护性。type_traits的类型判断功能，在编译期可以检查出是否是正确的类型，以能编写更安全的代码。

【实例分析】部分类型萃取的实现（类模板）

//#include <iostream>
//using namespace std;
/*********************const/volatile************************/
//remove const
template<typename _Tp>  //泛化
struct remove_const
{
    typedef _Tp   type;
};

template<typename _Tp>
struct remove_const<_Tp const> //特化
{
    typedef _Tp type;
};

//remove_volatile
template<typename _Tp>  //泛化
struct remove_volatile
{
    typedef _Tp  type;
};

template<typename _Tp>
struct remove_volatile<_Tp volatile>  //特化
{
    typedef _Tp  type;
};

//remove_cv
template<typename _Tp>
struct remove_cv
{
    typedef typename
    remove_const<typename remove_volatile<_Tp>::type>::type  type;
};

//add_const
template<typename _Tp>
struct add_const
{
    typedef _Tp const type;
};

/***********************integral_constant*************************/
//常量包装类型
template <class T, T v>
struct integral_constant
{
    static const T     value = v;
    typedef T          value_type;
    typedef integral_constant<T, v> type;
};

//定义true和false两个类型
typedef integral_constant<bool, true>  true_type;
typedef integral_constant<bool, false> false_type;

template<typename> //泛化
struct __is_void_helper : public false_type{};

template<>  //特化
struct __is_void_helper<void> : public true_type{};

//is_void
template<typename _Tp>
struct is_void : public __is_void_helper<typename remove_cv<_Tp>::type>::type{};

/***********************integral*************************/
template<typename>    //泛化
struct __is_integral_helper : public false_type{};

template<>  //特化: bool是intergal类型
struct __is_integral_helper<bool> : public true_type{};

template<>  //特化: char是intergal类型
struct __is_integral_helper<char> : public true_type{};

template<>  //特化: int是intergal类型
struct __is_integral_helper<int> : public true_type{};

template<>  //特化: usigned long long是intergal类型
struct __is_integral_helper<unsigned long long> : public true_type{};

//...

//is_integral
template<typename _Tp>
struct is_integral : public __is_integral_helper<typename remove_cv<_Tp>::type>::type{};

//is_const
template <class _Tp>
struct is_const : public integral_constant<bool, false> {};

template <class _Tp>
struct is_const<_Tp const> : public integral_constant<bool, true> {};

/********************enum/class/union**********************/
//is_enum  注意：__is_enum是编译器内置类型
template<typename _Tp>
struct is_enum : public integral_constant<bool, __is_enum(_Tp)>{};

//is_union 注意：__is_union是编译器内置类型
template<typename _Tp>
struct is_union : public integral_constant<bool, __is_union(_Tp)>{};

//is_class 注意：__is_class是编译器内置类型
template<typename _Tp>
struct is_class : public integral_constant<bool, __is_class(_Tp)>{};

//is_pod： 注意：__is_pod是编译器内置类型
template<typename _Tp>
struct is_pod : public integral_constant<bool, __is_pod(_Tp)>{};

int main()
{
    return ;
}

2. 类型判断

（1）基本类型（类模板：判断T是否是相应的类型）

　　①is_void、is_integral、is_array、is_floating_point(浮点)、 is_pointer

　　②is_enum、is_union、is_class

　　③is_lvalue_reference、is_rvalue_reference

　　④is_function、is_member_object_pointer(成员对象指针)、is_member_function_pointer(成员函数指针)

（2）复合类型（类模板）

　　①is_fundamental：是否是整型、浮点、void或null_ptr类型。

　　②is_arithemetic：是否是整型和浮点类型

　　③is_scalar：是否是arithemetic、enumeration、pointer、pointer to member或std::nullptr_t类型。

　　④is_object：是否为对象类型（不是函数、引用或void）

　　⑤is_compound：是否非fundamental类型构造的

　　⑥is_reference：是否为引用（含左值引用和右值引用）

　　⑦is_member_pointer：是否是成员指针（即非静态成员对象或函数的指针）

（3）类型的属性

　　①is_const、is_volatile、is_literal_type、is_signed、is_unsigned。

　　②is_trivial、is_trivially_copyable、is_standart_layout(标准内存布局，一般用于跨语言的兼容)、is_pod、is_empty(空类)

　　③is_polymorphic(是否有虚函数)、is_abstract(是否是抽象类)

3. 两个类型之间的关系

（1）is_same<T, U>： T和U的类型是否相同

（2）is_base_of<Base, Derived>：Base是否为Derived类型的基类

（3）is_convertible<From, To>：From是否能转为To模板参数类型。

【编程实验】基本type_traits和判断两个类型之间的关系

#include <iostream>

using namespace std;

class Parent{};
class Child : public Parent{}; //class Child : Parent{}，为private继承
class Alone{};

int main()
{
    cout << std::boolalpha; //以下的0、1按false和true格式输出

    /*基本的type_traits用法*/
    cout << is_const<int>::value << endl;         //false
    cout << is_const<const int>::value << endl;   //true
    cout << is_const<const int&>::value << endl;  //false
    cout << is_const<const int*>::value << endl;  //false
    cout << is_const<int* const>::value << endl;  //true

    /*is_same用法*/
    cout << is_same<int, int>::value << endl;         //true
    cout << is_same<int, unsigned int>::value << endl;//false
    cout << is_same<int, signed int>:: value << endl; //true

    /*is_base_of*/
    cout << is_base_of<Parent, Child>:: value << endl; //true
    cout << is_base_of<Child, Parent>:: value << endl; //false
    cout << is_base_of<Parent, Alone>:: value << endl; //false

    /*is_convertible<From, To>用法：判断From类型是否可以转为To类型*/
    cout << is_convertible<Parent*, Child*>:: value << endl; //false
    cout << is_convertible<Child*, Parent*>:: value << endl; //true
    cout << is_convertible<Parent*, Alone*>:: value << endl; //false
    return ;
}

4. 类型转换traits

（1）const-volatile限定符

　　①remove_cv<T>、remove_const<T>、remove_volatile<T>

　　②add_cv<T>、add_const<T>、add_volatile<T>

（2）引用： remove_reference<T>、add_lvalue_reference<T>、add_rlvalue_reference。

（3）指针： remove_pointer<T>、add_pointer<T>

（4）数组：remove_extent<T>移除数组顶层维度、remove_all_extents<T>移除所有维度。

（5）其它

　　①decay<T>：类型退化，主要用移除引用、cv符及为函数或数组添加指针。其转换规则如下。

　　　　A.先移除T的类型引用，得到类型U，U定义为remove_reference<T>::type。

　　　　B.如果is_array<U>::value为true，最终转换为remove_extent<U>::type*。

　　　　C.否则，如果is_function<U>::value为true，转换为add_pointer<U>::type。

　　　　D.否则，转换为remove_cv<U>::type。

　　②common_type<T1, T2, T3…>：获取公共类型

【编程实验】类型转换traits

#include <iostream>
#include <memory>

using namespace std;
//类型转换type_traits

//根据模板参数类创建对象时，要注意移除cv和引用
template<typename T>
class Test
{
    //typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type U;  //移除可能的引用和cv
    //以上的等价写法
    typedef typename std::decay<T>::type U; //先移除T的引用，再移除cv符，

    std::unique_ptr<U> m_ptr; //m_ptr智能指针

public:
    Test(): m_ptr(new U){} //创建智能指针时，需要获取T的原始类型

    typename std::add_lvalue_reference<U>::type //返回值类型，添加左值引用
    get() const
    {
        return *m_ptr.get();
    }
};

//利用std::decay保存函数指针
template<typename T>
class Sample
{
    using FnType = typename std::decay<T>::type; //为函数添加指针
    FnType m_fn;
public:
    Sample(T& f) : m_fn(f){};

    void run()
    {
        m_fn();
    }
};

void func()
{
    cout <<"void func()" << endl;
}

int main()
{
    cout << std::boolalpha; //以下的0、1按false和true格式输出

    //添加和移除const、reference
    cout <<is_same<const int, add_const<int>::type>::value << endl;         //true
    cout <<is_same<int, remove_const<const int>::type>::value << endl;      //true
    cout <<is_same<int&, add_lvalue_reference<int>::type>::value << endl;   //true
    cout <<is_same<int&&,add_rvalue_reference<int>::type>::value << endl;   //true
    cout <<is_same<int, remove_reference<int&>::type>::value << endl;       //true
    cout <<is_same<int, remove_reference<int&&>::type>::value << endl;      //true

      cout <<is_same<int*, add_pointer<int>::type>::value << endl;    //true

    //移除数组顶层维度
    cout <<is_same<int, remove_extent<int[]>::type>::value << endl;             //true
    cout <<is_same<int[], remove_extent<int[][]>::type>::value << endl;       //true
    cout <<is_same<int[][], remove_extent<int[][][]>::type>::value << endl; //true
    cout <<is_same<int, remove_all_extents<int[][][]>::type>::value << endl;  //true，移除所有维度

    //取公共类型
    typedef common_type<unsigned char, short, int>::type NumericType;
    cout <<is_same<int, NumericType>::value << endl;   //true

    //测试Test类
    Test<const int&> t; //T类型故意传入带cv和引用，Test类部在创建对象时，需去除这些属性
    int a = t.get();
    cout << a << endl;

    //std::decay
    cout <<is_same<int, decay<int>::type>::value << endl;              //true
    cout <<is_same<int, decay<int&&>::type>::value << endl;            //true,移除引用
    cout <<is_same<int, decay<const int&>::type>::value << endl;       //true,移除cv和引用
    cout <<is_same<int*, decay<int[]>::type>::value << endl;          //true,移除数组顶层维度
    cout <<is_same<int(*)(int), decay<int(int)>::type>::value << endl; //true,将函数变为函数指针

    Sample<decltype(func)> s(func);
    s.run();  //void func();

    return ;
}