STL源码剖析——全局函数construct(),destroy(),uninitialized_copy(),uninitialized_fill(),uninitialized_fill_n()

蔚落 2022-08-12 01:17 233阅读 0赞

前言

在STL中，内存处理时很关键的，特别是对于容器的实现，内存处理相当的重要。为了实现内存配置跟对象的构造行为分离开来，STL定义的五个基本全局函数，这五个全局函数中，贯穿在里面的基本上是Traits和__type_traits技术，之前看的时候不了解这两技术，因此，现在了解之后才来写这篇文章。有关Traits技术见前文《Traits编程技术》。

STL五个全局函数分别是：construct(),destroy(),uninitialized_copy(),uninitialized_fill(),uninitialized_fill_n();以下分别对这些函数进行讲解。

构造和析构基本工具：construct()和destroy()

在STL源码中,内存的配置和对象的构造与析构是分离开的，这两个函数实现对象的构造和析构，不进行分配内存空间，construct()函数在已分配内存上构造对象，具体实现看下面的源码及其解析：

  1. #ifndef __SGI_STL_INTERNAL_CONSTRUCT_H
  2. #define __SGI_STL_INTERNAL_CONSTRUCT_H
  4. #include <new.h>
  6. __STL_BEGIN_NAMESPACE
  8. // construct and destroy.  These functions are not part of the C++ standard,
  9. // and are provided for backward compatibility with the HP STL.  We also
  10. // provide internal names _Construct and _Destroy that can be used within
  11. // the library, so that standard-conforming pieces don't have to rely on
  12. // non-standard extensions.
  14. // Internal names
  16. template <class _T1, class _T2>
  17. //参数接受一个指针和一个初值
  18. inline void _Construct(_T1* __p, const _T2& __value) {
  19.   new ((void*) __p) _T1(__value);/*这里是placement new;调用构造函数T1::T1(value)
  20.                                  *将初值设定到指针所指的空间上
  21.                                  */
  22. }
  24. template <class _T1>
  25. //这里只接受指针
  26. inline void _Construct(_T1* __p) {
  27.   new ((void*) __p) _T1();//这里是placement new;调用默认构造函数T1::T1()
  28. }
  30. template <class _Tp>
  31. inline void _Destroy(_Tp* __pointer) {//第一个版本：接受一个指针
  32.   __pointer->~_Tp();//调用对象析构函数，析构指针所指对象
  33. }
  36. template <class _ForwardIterator>
  37. /*第二个版本：接受两个迭代器first和last，自迭代器first开始到迭代器last结束，析构每个元素对象
  38. *为求最大效率，首先以__VALUE_TYPE()萃取出迭代器first的value_type
  39. *再利用__type_traits判断该型别是否trivial destructor*/
  40. inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
  41.   __destroy(__first, __last, __VALUE_TYPE(__first));
  42. }
  44. template <class _ForwardIterator, class _Tp>
  45. inline void 
  46. __destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
  47. {//利用__type_traits判断元素的数值型别是否有trivial destructor
  48.   typedef typename __type_traits<_Tp>::has_trivial_destructor
  49.           _Trivial_destructor;
  50.   __destroy_aux(__first, __last, _Trivial_destructor());
  51. }
  53. template <class _ForwardIterator> 
  54. /*若元素型别是有trivial destructor，就派送到该函数
  55. */
  56. inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}
  58. template <class _ForwardIterator>
  59. void
  60. __destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
  61. {//若元素型别不具有trivial destructor，就派送到该函数
  62.   for ( ; __first != __last; ++__first)
  63.     destroy(&*__first);//这里最终还是调用了指针版的析构函数,析构每个元素对象
  64. }
  66. //以下是第二版析构函数针对内置类型的特化版
  67. inline void _Destroy(char*, char*) {}
  68. inline void _Destroy(int*, int*) {}
  69. inline void _Destroy(long*, long*) {}
  70. inline void _Destroy(float*, float*) {}
  71. inline void _Destroy(double*, double*) {}
  72. #ifdef __STL_HAS_WCHAR_T
  73. inline void _Destroy(wchar_t*, wchar_t*) {}
  74. #endif /* __STL_HAS_WCHAR_T */
  76. // --------------------------------------------------
  77. // Old names from the HP STL.
  79. template <class _T1, class _T2>
  80. inline void construct(_T1* __p, const _T2& __value) {
  81.   _Construct(__p, __value);
  82. }
  84. template <class _T1>
  85. inline void construct(_T1* __p) {
  86.   _Construct(__p);
  87. }
  89. template <class _Tp>//参数为指针版的析构函数
  90. inline void destroy(_Tp* __pointer) {
  91.   _Destroy(__pointer);
  92. }
  94. template <class _ForwardIterator>//参数为迭代器版的析构函数
  95. inline void destroy(_ForwardIterator __first, _ForwardIterator __last) {
  96.   _Destroy(__first, __last);
  97. }
  99. __STL_END_NAMESPACE
  101. #endif /* __SGI_STL_INTERNAL_CONSTRUCT_H */
  103. // Local Variables:
  104. // mode:C++
  105. // End:

未初始化空间的复制和初始化：uninitialized_copy(),uninitialized_fill()和uninitialized_fill_n()

在未初始化空间中，要对对象进行初始化时，会用到这些函数，该源码在文件中，具体实现看下面源码及其解析：

  1. #ifndef __SGI_STL_INTERNAL_UNINITIALIZED_H
  2. #define __SGI_STL_INTERNAL_UNINITIALIZED_H
  4. __STL_BEGIN_NAMESPACE
  6. // uninitialized_copy
  8. // Valid if copy construction is equivalent to assignment, and if the
  9. //  destructor is trivial.
  10. template <class _InputIter, class _ForwardIter>
  11. /*该函数接受三个迭代器参数：迭代器first是输入的起始地址，
  12. *迭代器last是输入的结束地址，迭代器result是输出的起始地址
  13. *即把数据复制到[result,result+(last-first)]这个范围
  14. *为了提高效率，首先用__VALUE_TYPE()萃取出迭代器result的型别value_type
  15. *再利用__type_traits判断该型别是否为POD型别
  16. */
  17. inline _ForwardIter
  18.   uninitialized_copy(_InputIter __first, _InputIter __last,
  19.                      _ForwardIter __result)
  20. {
  21.   return __uninitialized_copy(__first, __last, __result,
  22.                               __VALUE_TYPE(__result));
  23. }
  25. template <class _InputIter, class _ForwardIter, class _Tp>
  26. inline _ForwardIter
  27. /*利用__type_traits判断该型别是否为POD型别*/
  28. __uninitialized_copy(_InputIter __first, _InputIter __last,
  29.                      _ForwardIter __result, _Tp*)
  30. {
  31.   typedef typename __type_traits<_Tp>::is_POD_type _Is_POD;
  32.   return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
  33. }
  35. template <class _InputIter, class _ForwardIter>
  36. _ForwardIter //若不是POD型别，就派送到这里
  37. __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
  38.                          _ForwardIter __result,
  39.                          __false_type)
  40. {
  41.   _ForwardIter __cur = __result;
  42.   __STL_TRY {//这里加入了异常处理机制
  43.     for ( ; __first != __last; ++__first, ++__cur)
  44.       _Construct(&*__cur, *__first);//构造对象，必须是一个一个元素的构造，不能批量
  45.     return __cur;
  46.   }
  47.   __STL_UNWIND(_Destroy(__result, __cur));//析构对象
  48. }
  50. template <class _InputIter, class _ForwardIter>
  51. inline _ForwardIter //若是POD型别，就派送到这里
  52. __uninitialized_copy_aux(_InputIter __first, _InputIter __last,
  53.                          _ForwardIter __result,
  54.                          __true_type)
  55. {
  56.     /*调用STL的算法copy()
  57.     *函数原型：template< class InputIt, class OutputIt >
  58.     * OutputIt copy( InputIt first, InputIt last, OutputIt d_first );
  59.     */
  60.     return copy(__first, __last, __result);
  61. }
  62. //下面是针对char*，wchar_t* 的uninitialized_copy()特化版本
  63. inline char* uninitialized_copy(const char* __first, const char* __last,
  64.                                 char* __result) {
  65. /* void* memmove( void* dest, const void* src, std::size_t count );
  66. * dest指向输出的起始地址
  67. * src指向输入的其实地址
  68. * count要复制的字节数
  69. */
  70.   memmove(__result, __first, __last - __first);
  71.   return __result + (__last - __first);
  72. }
  74. inline wchar_t* 
  75. uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
  76.                    wchar_t* __result)
  77. {
  78.   memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
  79.   return __result + (__last - __first);
  80. }
  83. // Valid if copy construction is equivalent to assignment, and if the
  84. // destructor is trivial.
  85. template <class _ForwardIter, class _Tp>
  86. /*若是POD型别，则调用此函数
  87.     */
  88. inline void
  89. __uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
  90.                          const _Tp& __x, __true_type)
  91. {
  92. /*函数原型：template< class ForwardIt, class T >
  93.   * void fill( ForwardIt first, ForwardIt last, const T& value );  
  94.   */
  95.     fill(__first, __last, __x);
  96. }
  98. template <class _ForwardIter, class _Tp>
  99. /*若不是POD型别，则调用此函数
  100.     */
  101. void
  102. __uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last, 
  103.                          const _Tp& __x, __false_type)
  104. {
  105.   _ForwardIter __cur = __first;
  106.   __STL_TRY {
  107.     for ( ; __cur != __last; ++__cur)
  108.       _Construct(&*__cur, __x);
  109.   }
  110.   __STL_UNWIND(_Destroy(__first, __cur));
  111. }
  113. template <class _ForwardIter, class _Tp, class _Tp1>
  114. //用__type_traits技术判断该型别是否
  115. 为POD型别
  116. inline void __uninitialized_fill(_ForwardIter __first, 
  117.                                  _ForwardIter __last, const _Tp& __x, _Tp1*)
  118. {
  119.   typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  120.   __uninitialized_fill_aux(__first, __last, __x, _Is_POD());
  122. }
  124. template <class _ForwardIter, class _Tp>
  125. /*该函数接受三个参数：
  126. *迭代器first指向欲初始化的空间起始地址
  127. *迭代器last指向欲初始化的空间结束地址
  128. *x表示初值
  129. *首先利用__VALUE_TYPE()萃取出迭代器first的型别value_type
  130. *然后用__type_traits技术判断该型别是否为POD型别
  131. */
  132. inline void uninitialized_fill(_ForwardIter __first,
  133.                                _ForwardIter __last, 
  134.                                const _Tp& __x)
  135. {
  136.   __uninitialized_fill(__first, __last, __x, __VALUE_TYPE(__first));
  137. }
  139. // Valid if copy construction is equivalent to assignment, and if the
  140. //  destructor is trivial.
  141. template <class _ForwardIter, class _Size, class _Tp>
  142. inline _ForwardIter
  143.     /*若是POD型别，则调用此函数
  144.     */
  145. __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
  146.                            const _Tp& __x, __true_type)
  147. {
  148.   /*调用STL算法
  149.   *原型：template< class OutputIt, class Size, class T >
  150.   * void fill_n( OutputIt first, Size count, const T& value );
  151.   * template< class OutputIt, class Size, class T >
  152.   * OutputIt fill_n( OutputIt first, Size count, const T& value );
  153.   */
  154.     return fill_n(__first, __n, __x);
  155. }
  157. template <class _ForwardIter, class _Size, class _Tp>
  158. _ForwardIter
  159.     /*若不是POD型别，则调用此函数
  160.     */
  161. __uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
  162.                            const _Tp& __x, __false_type)
  163. {
  164.   _ForwardIter __cur = __first;
  165.   __STL_TRY {
  166.     for ( ; __n > 0; --__n, ++__cur)
  167.       _Construct(&*__cur, __x);
  168.     return __cur;
  169.   }
  170.   __STL_UNWIND(_Destroy(__first, __cur));
  171. }
  173. template <class _ForwardIter, class _Size, class _Tp, class _Tp1>
  174. inline _ForwardIter 
  175.     //用__type_traits技术判断该型别是否为POD型别
  176. __uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x, _Tp1*)
  177. {
  178.   typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  179.   //_Is_POD()判断value_type是否为POD型别
  180.   return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
  181. }
  183. template <class _ForwardIter, class _Size, class _Tp>
  184. inline _ForwardIter 
  185. /*该函数接受三个参数：
  186. *迭代器first指向欲初始化的空间起始地址
  187. *n表示欲初始化空间大小
  188. *x表示初值
  189. *首先利用__VALUE_TYPE()萃取出迭代器first的型别value_type
  190. *然后用__type_traits技术判断该型别是否为POD型别
  191. */
  192. uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
  193. {
  194.   //__VALUE_TYPE(__first)萃取出first的型别value_type
  195.     return __uninitialized_fill_n(__first, __n, __x, __VALUE_TYPE(__first));
  196. }
  200. __STL_END_NAMESPACE
  202. #endif /* __SGI_STL_INTERNAL_UNINITIALIZED_H */
  204. // Local Variables:
  205. // mode:C++
  206. // End:

总结

在这个五个全局函数中，我们可以看到，基本上是Traits和__type_traits技术的作用，方便内存处理，并且提高效率。

发表评论

表情：
评论列表 （有 0 条评论，233人围观）

还没有评论，来说两句吧...

相关阅读

    相关 【STL源码剖析】Sort算法

    前言：sort算法必须拿出来单独将，因为它是STL所有算法中最复杂最庞大的一个，就像我肯定会把copy算法单独列出来一样，这两个算法太重要了。 提示：STL算法特点是，前两个

    亦凉亦凉/ 0 赞/ 326 阅读

    相关 STL源码剖析--vector

    vector容器概述       vector的数据安排以及操作方式，与array非常相似。两者的唯一区别在于空间的运用的灵活性。array是静态空间，一旦配置了就不能改变

    心已赠人心已赠人/ 0 赞/ 355 阅读

    相关 STL源码剖析1

    stl概论 stl以抽象概念为主题而非以实际类为主的结构，形成了一个严谨的接口标准。在此接口之下，任何组件都有最大的独立性，并以所谓迭代器胶合起来，或以所谓配接器互相配接，或

    爱被打了一巴掌爱被打了一巴掌/ 0 赞/ 327 阅读