type-traits源码分析-三

最新推荐文章于 2024-06-09 20:18:37 发布

__JAN__

最新推荐文章于 2024-06-09 20:18:37 发布

阅读量613

点赞数

分类专栏： C++ TMP 文章标签： c++ 后端 C++标准库模板元编程

本文链接：https://blog.csdn.net/JAN6055/article/details/127177443

版权

C++ 同时被 2 个专栏收录

58 篇文章 21 订阅

订阅专栏

TMP

5 篇文章 0 订阅

订阅专栏

title: type-traits源码分析(三)
date: 2022-09-28 10:34:42
tags:
- Modern C++
- C++
- C++ Library

在第三章中，会有一些新的东西，不同于一二章，TMP开始加速了！你将会看见额外的一些元函数实现手法，你肯定会惊讶它的巧妙，特别是void_t类型。总之，做好准备，这章的难度可不同于以往了！

实现

__is_one_of

传入一个类型T和一个参数包Ts，返回其T是不是Ts其中的一个类型，如果是，返回值/类型为 true/true_type, 否则返回false/false_type。

有了这个type_traits，可以更加轻松的实现其他type_traits。

这个type_traits的实现方式也是比较的有意思。我们可以有很多种方式来实现__is_one_of这个元函数，包括使用模板递归继承的方式来实现。gcc则是采用的参数包模式展开的方式。

  template<typename _Tp, typename... _Types>
    using __is_one_of = __or_<is_same<_Tp, _Types>...>; //用is_same这个模式来对参数包展开，相当于每个类型都和_Tp应用于is_same,再用作于__or_，即可获得结果。

__is_signed/unsinged_integer

入一个类型，返回其是不是，如一个有符号/无符号的整数果是，返回值/类型为 true/true_type, 否则返回false/false_type。

  // Check if a type is one of the signed integer types.
  template<typename _Tp>
    using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, //继承__is_one_of<符合要求的类型参数包>
	  signed char, signed short, signed int, signed long,
	  signed long long
#if defined(__GLIBCXX_TYPE_INT_N_0)			//条件编译大可忽略
	  , signed __GLIBCXX_TYPE_INT_N_0
#endif
#if defined(__GLIBCXX_TYPE_INT_N_1)
	  , signed __GLIBCXX_TYPE_INT_N_1
#endif
#if defined(__GLIBCXX_TYPE_INT_N_2)
	  , signed __GLIBCXX_TYPE_INT_N_2
#endif
#if defined(__GLIBCXX_TYPE_INT_N_3)
	  , signed __GLIBCXX_TYPE_INT_N_3
#endif
	  >;

实现方式大同小异

  // Check if a type is one of the unsigned integer types.
  template<typename _Tp>
    using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
	  unsigned char, unsigned short, unsigned int, unsigned long,
	  unsigned long long
#if defined(__GLIBCXX_TYPE_INT_N_0)
	  , unsigned __GLIBCXX_TYPE_INT_N_0
#endif
#if defined(__GLIBCXX_TYPE_INT_N_1)
	  , unsigned __GLIBCXX_TYPE_INT_N_1
#endif
#if defined(__GLIBCXX_TYPE_INT_N_2)
	  , unsigned __GLIBCXX_TYPE_INT_N_2
#endif
#if defined(__GLIBCXX_TYPE_INT_N_3)
	  , unsigned __GLIBCXX_TYPE_INT_N_3
#endif
	  >;

__is_standard_integer

传入一个类型，返回其是不是标准定义的整数，如果是，返回值/类型为 true/true_type, 否则返回false/false_type。

这个type_traits是其他type_traits组合起来的一个别名。这也是元函数的一个实现手法。

  // Check if a type is one of the signed or unsigned integer types.
  template<typename _Tp>
    using __is_standard_integer
      = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;

void_t

void_t，就是一个void的别名，但是带有类型参数。你会说：这不是脱裤子放屁吗？有什么用，我直接写void不好吗？

实际上void_t是为TMP服务的，并不是让你当作返回值/类型声明的。我们可以通过SFINE+void_t这种TMP的手法来实现看似不可能的元函数。你马上就会看到

至于你说为什么叫void_t而不是叫其他类型，那你去问问C++委员会吧，顺便告诉我，我也想知道。

  // __void_t (std::void_t for C++11)
  template<typename...> using __void_t = void;

__is_referenceable

传入一个类型，返回其是不是可引用的，如果是，返回值/类型为 true/true_type, 否则返回false/false_type。

需要注意：一个类型T，如果已经是一个引用，无论是左值还是右值，均不可再添加&，就是说没有(int &) &这样的语法，即引用的引用。但是在模板中，有引用的折叠，别把这件事情忘了。

拿什么是不可引用的呢？

void
例如int () const这样的函数

  // Utility to detect referenceable types ([defns.referenceable]).

  template<typename _Tp, typename = void> //第二个类型参数用于辅助，不需要有名字。
    struct __is_referenceable
    : public false_type
    { };

  template<typename _Tp>
    struct __is_referenceable<_Tp, __void_t<_Tp&>> //如果是一个不可引用的类型，匹配这个特例化失败，转而匹配主模板
    : public true_type
    { };

一些特殊的类型

C++中有一些类型，具有独特的语义。例如无其他动作的构造。内存布局方式是标准的。无其他动作的拷贝。一个抽象基类，一个被final修饰的类,等等deng’den。想对这些类型实现type_traits不是不行，但是编译器为我们内置这样的功能可能会更好，编译速度也会更加快速。

trivial

一个trivial需要具有一下的性质

有默认构造函数，编译器生成的，或者是显示的=default，只能是这两种情况。
内存空间是连续的
不能包含虚函数和虚基类。
成员可以具有不同的访问权限
拥有平凡的拷贝构造函数和移动构造函数。默认的意思同上，也可以使用=default。
拥有平凡的拷贝赋值运算符和移动赋值运算符。

stand_layout

一个stand_layout的对象，需要满足以下几种性质

所有非静态成员拥有相同的访问级别
类中第一个非静态类型与基类不是同一个类型
所有非静态数据成员都符合标准布局的要求
没有虚类和虚基类
继承时需要满足以下两个情况之一
1. 派生类中有非静态类，那么这个派生类只能有且只有一个仅包含了静态成员的基类。
2. 基类有非静态成员，那么派生类中不允许有非静态成员。

ps：这里涉及到C++对象模型，感兴趣的可以自行学习。

pod

pod类型需要满足两个要求

是一个人trivial类型
是一个stand_layout类型

pod类型的一些优势/特点

POD类型兼容C内存布局，C++可以直接使用C库函数操作POD数据类型，POD类型在C和C++间的操作总是安全的
POD类型可以直接使用字节赋值，使用C语言库函数进行二进制形式的数据交换，包括但不限于如下操作memmove,memcpy等
静态初始化在很多时候可以提高程序性能，而POD类型的静态初始化非常简单（放入目标文件的.bss段，在初始化时直接赋0）
虽然与C完全兼容，但是仍然可以有成员函数
有更长的生命周期（从资源获取到资源释放），非POD类型的生命周期从构造函数结束到析构函数结束
POD类型对象的前部没有填充字节，因此对象指针等于对象第一个成员的指针

ps：还是涉及到C++对象模型，有点头秃，大伙看看就好，毕竟术业有专攻。编写应用层C++/非底层库看看就好。

STL的一些算法为了优化性能就会使用is_pod+标签分派的手法来优化性能。在一些很老的标准库中，你会看见对is_pod的手动实现

literal_type

简单的说，就可以在用于编译期运算的对象。注意其和字面量的区别。

还有一些编译器为我们内置的type_traits

这些type_traits的共呢个正如他们的名字所言，你唯一搞不懂的，应当是什么是POD类型？什么又是trivially_copyable性质？

 /// is_trivial
//普通类型是其存储是连续的普通可复制的，并且仅支持静态默认初始化，无论是否为 cv 限定。它包括标量类型，平凡类和任何此类类型的数组。其实现也是编译器内置的。
  template<typename _Tp>
    struct is_trivial 
    : public integral_constant<bool, __is_trivial(_Tp)>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), //这里的静态断言，我们在前面说过了，不再解释，下同。
	"template argument must be a complete class or an unbounded array");
    };

  // is_trivially_copyable
  template<typename _Tp>
    struct is_trivially_copyable 	//是否具有平凡的拷贝
    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
	"template argument must be a complete class or an unbounded array");
    };

  /// is_standard_layout
  template<typename _Tp>
    struct is_standard_layout	//是否是一个标准布局
    : public integral_constant<bool, __is_standard_layout(_Tp)>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
	"template argument must be a complete class or an unbounded array");
    };

  /// is_pod (deprecated in C++20) C++20中已经废弃
  // Could use is_standard_layout && is_trivial instead of the builtin.
  template<typename _Tp>	
    struct
    _GLIBCXX20_DEPRECATED("use is_standard_layout && is_trivial instead")
    is_pod
    : public integral_constant<bool, __is_pod(_Tp)>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
	"template argument must be a complete class or an unbounded array");
    };

  /// is_literal_type
  //17开始 20弃用
  template<typename _Tp>
    struct
    _GLIBCXX17_DEPRECATED
    is_literal_type 		//是否是一个字面类型
    : public integral_constant<bool, __is_literal_type(_Tp)>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
	"template argument must be a complete class or an unbounded array");
    };

  /// is_empty
  template<typename _Tp>
    struct is_empty			//是否是一个空类型，即类中为空实现
    : public integral_constant<bool, __is_empty(_Tp)>
    { };

  /// is_polymorphic
  template<typename _Tp>
    struct is_polymorphic		// 是否是一个多态类
    : public integral_constant<bool, __is_polymorphic(_Tp)>
    { };

#if __cplusplus >= 201402L
#define __cpp_lib_is_final 201402L
  /// is_final
  template<typename _Tp>
    struct is_final		
    : public integral_constant<bool, __is_final(_Tp)>
    { };
#endif

  /// is_abstract
  template<typename _Tp>
    struct is_abstract
    : public integral_constant<bool, __is_abstract(_Tp)>
    { };

is_signed

template<typename _Tp,
  bool = is_arithmetic<_Tp>::value> //默认参数是一个bool值,来判断书不是算数类型
  struct __is_signed_helper
  : public false_type { };

template<typename _Tp>
  struct __is_signed_helper<_Tp, true>	//蕴含着是一个符号类型应当先是算数类型
  : public integral_constant<bool, _Tp(-1) < _Tp(0)>	//如果是一个有符号类型，那么_Tp(-1) < _Tp(0)得到的结果将会是false，是一个无符号类型，-1，会下溢结果为true。
  { };

/// is_signed
template<typename _Tp>
  struct is_signed
  : public __is_signed_helper<_Tp>::type
  { }

is_unsigned

  /// is_unsigned
  template<typename _Tp>
    struct is_unsigned
    : public __and_<is_arithmetic<_Tp>/*也可以不加这个元函数，is_singed中有*/, __not_<is_signed<_Tp>>> //算数类型的同时对is_singed取反
    { };

decltype手法

C++11中新增了decltype关键字，目的就是解决TMP中的一些问题。decltype会对表达式求值，只会根据表达式来推导类型，这点牢记。我不打算说明decltype的所有细节，你可以查阅资料来了解相关知识。decltype为TMP的实现提供了更多的可能性。decltype+SFINAE也是TMP中的一种很巧妙的手法。

declval

declval是一个函数，只有声明，没有实现，目的很简单，服务于TMP。因此，关于declval的所有操作，均在编译时期发生。

  /**
   *  @brief  Utility to simplify expressions used in unevaluated operands
   *  @ingroup utilities
   */
//提供了两个的重载版本
  template<typename _Tp, typename _Up = _Tp&&>
    _Up
    __declval(int);

  template<typename _Tp>
    _Tp
    __declval(long);

  template<typename _Tp>
    auto declval() noexcept -> decltype(__declval<_Tp>(0)); //尾置返回类型

extent

如果T是数组类型，则提供成员常量等于数组第nth维的元素数。或者T是其他类型，或者数组的第0维数为无界的并且nth=0，则值为0。

你可能会疑惑为什么第0维是无界的时候值为0，第1，2，…维不行吗？别忘了C的语法——要确定数组的列数。

  /// extent
  template<typename, unsigned _Uint>	
    struct extent
    : public integral_constant<std::size_t, 0> { };	  //T不是数组类型，值为0

  template<typename _Tp, unsigned _Uint, std::size_t _Size>
    struct extent<_Tp[_Size], _Uint>
    : public integral_constant<std::size_t,
			       _Uint == 0 ? _Size : extent<_Tp,   //三目运算符
							   _Uint - 1>::value>	//递归条件_Uint == 0，在_Uint==0的时候，编译器推断的size正好是nth的长度，实现很巧妙，多看几眼慢慢搞清顺序。
    { };

  template<typename _Tp, unsigned _Uint>
    struct extent<_Tp[], _Uint>				//如果是一个无界数组
    : public integral_constant<std::size_t,
			       _Uint == 0 ? 0 : extent<_Tp,	//如果是第0维，那么值就是0，否则就递归的继承，回到了上述的情况
						       _Uint - 1>::value> 
    { };

用法：

int main() {
    int arr [][3][2] = {};
    cout << std::extent<int[][3][5],0>::value << endl;  //0
    cout << std::extent<int[][3][5],1>::value << endl;  //3
    cout << std::extent<int[][3][5],2>::value << endl;  //5
    int arr1[1][2];
    cout << std::extent<decltype(arr1),0>::value << endl;   //1
    cout << std::extent<decltype(arr1),1>::value << endl;   //2
    
    //decltype(arr)的结果为什么超出我么的预期？gcc出bug了吗？
    cout << std::extent<decltype(arr),0>::value << endl;    //0
    cout << std::extent<decltype(arr),1>::value << endl;    //0
    cout << std::extent<decltype(arr),2>::value << endl;    //0
    return 0;
}

其实decltype的推导arr的结果为[0][3][2]。是不同于直接传递int[][3][5]的。decltype的推断出一个有界数组，而直接传递arr，arr被当作一个无界数组。

rank

传入一个类型，返回其数组的维数。

同样是使用递归+继承的方式来实现。

  /// rank
  template<typename>
    struct rank
    : public integral_constant<std::size_t, 0> { };

  template<typename _Tp, std::size_t _Size>
    struct rank<_Tp[_Size]>
    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };

  template<typename _Tp>
    struct rank<_Tp[]>
    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };