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

时间:2022-02-03 08:35:56

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