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

Posted 浅墨浓香

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第17课 类型萃取_基本的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 0;
}

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 0;
}

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[2], remove_extent<int[][2]>::type>::value << endl;       //true     
    cout <<is_same<int[2][3], remove_extent<int[][2][3]>::type>::value << endl; //true 
    cout <<is_same<int, remove_all_extents<int[][2][3]>::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[2]>::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 0;
}

以上是关于第17课 类型萃取_基本的type_traits的主要内容,如果未能解决你的问题,请参考以下文章

STL源码剖析——Iterators与Traits编程#5 __type_traits

还搞不懂STL的type_traits?从源码来带你一起分析!!!

还搞不懂STL的type_traits?从源码来带你一起分析

SFINAE 与 type_traits

STL源码分析--traits

STL:construct 与 destroy