自己动手实现STL 02：构造析构的基本工具construct()和destroy()(stl_construct.h)

一、前言

　　上一篇，我先完成了对内存配置器的实现。然而后面在内存上的算法还依赖于两个全局函数，construct()和destroy()，前者负责在指定的内存上调用对象的构造函数，在内存上构造出对象。后者则是相反，在指定内存上调用对象的析构函数，销毁对象。(注意：这两个函数不涉及对象内存的分配和释放，对象构造在指定的已分配好的内存上，析构也只是销毁对象，对于对象占用的那块内存，没有释放，如需释放，还需自己去free)。

二、全局construct()函数简介

　　construct(),主要功能前面已经说明，其在指定内存上构造对象。在指定内存上构造对象的功能，我们一般使用placement new。这里也是如此。construct()函数实现比较简单。实现如下：

 // construct()
 // 接受一个已分配好的内存，在其上以value为构造函数参数的来构造一个T1对象
 template <class T1, class T2>
 inline void construct(T1* p, const T2& value)
 {
     new (p) T1(value);  //placement new; 调用T1::T1(value);
 }

三、全局的destroy()函数简介

　　destroy()函数实现就比construct()复杂一点。这里利用了对象类型的类型属性的不同进行重载，对于不同对象的destroy都进行最适当的处理。我先把destroy()的泛化到特化的过程展示如下：

图1：destroy()和construct()示意

1.destroy()的第一个版本

　　第一个版本只接受一个对象指针，其是对于单个对象的析构。很简单，只是调用对象本身的析构函数即可。

 // destroy() 第一个版本
 // destroy接受一个对象指针,调用该对象的析构函数
 // 注意：destroy函数只析构对象，没有释放其内存
 template <class T>
 inline void destroy(T* pointer)
 {
     pointer->~T(); //调用dtor ~T()
 }

2.destroy()的第二版本

　　对于destroy()的第二版本，他接受两个迭代器标识的一段区间，对该区间内所有对象进行析构。　　

　　第二版本，首先destroy()对于外部的有一个统一接口destroy()模版函数：

 template <class ForwardIterator>
 inline void destroy(ForwardIterator first, ForwardIter last)
 {
     // 利用value_type()函数提取处迭代器所指向的类型，
     // 并用其类型产生一个临时对象，利用编译器的类型推导，
     // 获取迭代器指向类型，以便后面萃取其相关属性
     __destroy(first, last, value_type(first));
 }

　　其中value_type()也是一个函数模版，其主要作用是，利用编译器的类型推导，得到迭代器的类型，再利用迭代器的属性萃取类型，得到迭代器的内嵌类型value_type。并利用编译器的类型推导，在__destroy()函数中取得迭代器的value_type内嵌类型。(注：在STL的迭代器都有五个内嵌类型，其中value_Type,用于表示迭代器的指向对象的类型。同时，还有一个全局的函数value_type()，用于提取出迭代器的value_type，并用该类型生成一个该类型的指针)

 template <class Iterator>
 inline typename iterator_traits<Iterator>::value_type*
 value_type(const Iterator&)
 {
     // 制造一个指针类型，比制造对象用于重载效率要高
     return static_cast<typename iterator_traits<Iterator>::value_type*>();
 }

　　由destroy()---->__destroy()主要为了利用编译器的类型推导功能，获取迭代器的指向对象的类型value_type

 template <class ForwardIterator, class T>
 inline void __destroy(ForwardIterator first, ForwardIterator last, T*)
 {
     // 利用__type_traits萃取处T类型的析构析构函数的否是trivial，
     // 并利用其has_trivial_destructor的定义类型，产生一个临时对象
     // 利用其进行重载
     typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
     return __destroy_aux(first, last, trivial_destructor());
 }

　　在__destroy()函数中，又利用了用来类型属性萃取的类型__type_traits，萃取迭代器指向对象类型的一些属性。在这里，就是萃取迭代器指向对象类型对于是否有trivial析构函数的定义，并利用该定义的类型生成临时对象用于重载。

　　对于has_trivial_destructor类型的具体定义的类型为__false_type(__false_type和__true_type都是类型，他们是标签类型，主要是表示一个属性是否为真。使用标签类型，主要是为了能够利用类型进行重载，这样就可以对于不同属性的结果进行不同的处理)，那么说明迭代器指向类型的析构函数是non-trivail的，那么需要调用对象的析构函数。

 // dtor 是 non-trivial的，必须逐个调用析构函数析构
 template <class ForwardIterator>
 inline void
 __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type)
 {
     for (; first < last; ++first)
         destory(&*first);  //调用第一个版本，以调用析构函数
 }

　　对于has_trivial_destructor类型的具体定义的类型为__true_type，那么迭代器指向对象类型的析构函数，其实是无用的，那么就可以不用调用了。

 // dtor 是trivial的，不用调用析构函数
 template <class ForwardIterator>
 inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {}

　　最后，对于char*和wchar_t*类型的迭代器，由于char和wchar_t其都是内置类型，他们没有析构函数，也可以认为其析构是trivial的，那么就不用调用析构函数了。由于，如果采用上面的版本，还需要进行__destroy()和__destroy_aux()，这样的调用其实是无用的，因为最后什么都没有执行，为了效率的考虑，直接对第二版的destroy()函数模版进行特化。

// 针对char*的特化版本

// 对于迭代器类型是char*的，由于其char类型利用__type_traits
// 萃取出，其应用调用__destroy_aux(ForwardIterator, ForwardIterator, __true_type)
// 但是函数其实其实什么都没有执行，却在调用了函数，并可能产生几个临时对象，
// 所以针对char*类型的迭代器进行特化，避免上述情况出现，提高效率
inline void destroy(char *, char *) {}

// 针对wchar_t*的特化版本
// 原理同上
inline void destory(wchar_t*, wchar_t*) {}

四、stl_construct.h的完整实现源码

　　如下：

 /*************************************************************************
     > File Name: stl_construct_wjzh.h
     > Author: wjzh
     > Mail: wangjzh_1@163.com
     > Created Time: 2014年11月06日 星期四 14时35分29秒
  ************************************************************************/

 // 该文件中提供构造和析构的基本工具

 #ifndef __SGI_STL_INTERNAL_CONSTRUCT_WJZH_H
 #define __SGI_STL_INTERNAL_CONSTRUCT_WJZH_H 

 #include <new.h>

 __STL_BEGIN_NAMESPACE

 // destroy() 第一个版本
 // destroy接受一个对象指针,调用该对象的析构函数
 // 注意：destroy函数只析构对象，没有释放其内存
 template <class T>
 inline void destroy(T* pointer)
 {
     pointer->~T(); //调用dtor ~T()
 }

 // construct()
 // 接受一个已分配好的内存，在其上以value为构造函数参数的来构造一个T1对象
 template <class T1, class T2>
 inline void construct(T1* p, const T2& value)
 {
     new (p) T1(value);  //placement new; 调用T1::T1(value);
 }

 // destory(第二个版本实现)
 // 接受两个迭代器，在两个迭代器标示的区间内逐个以最适当的方式析构
 // 迭代器所指向的对象

 // dtor 是 non-trivial的，必须逐个调用析构函数析构
 template <class ForwardIterator>
 inline void
 __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type)
 {
     for (; first < last; ++first)
         destory(&*first);  //调用第一个版本，以调用析构函数
 }

 // dtor 是trivial的，不用调用析构函数
 template <class ForwardIterator>
 inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {}

 template <class ForwardIterator, class T>
 inline void __destroy(ForwardIterator first, ForwardIterator last, T*)
 {
     // 利用__type_traits萃取处T类型的析构析构函数的否是trivial，
     // 并利用其has_trivial_destructor的定义类型，产生一个临时对象
     // 利用其进行重载
     typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
     return __destroy_aux(first, last, trivial_destructor());
 }

 template <class ForwardIterator>
 inline void destroy(ForwardIterator first, ForwardIter last)
 {
     // 利用value_type()函数提取处迭代器所指向的类型，
     // 并用其类型产生一个临时对象，利用编译器的类型推导，
     // 获取迭代器指向类型，以便后面萃取其相关属性
     __destroy(first, last, value_type(first));
 }

 // 针对char*的特化版本

 // 对于迭代器类型是char*的，由于其char类型利用__type_traits
 // 萃取出，其应用调用__destroy_aux(ForwardIterator, ForwardIterator, __true_type)
 // 但是函数其实其实什么都没有执行，却在调用了函数，并可能产生几个临时对象，
 // 所以针对char*类型的迭代器进行特化，避免上述情况出现，提高效率
 inline void destroy(char *, char *) {}

 // 针对wchar_t*的特化版本
 // 原理同上
 inline void destory(wchar_t*, wchar_t*) {}

 __STL_END_NAMESPACE

 #endif /* __SGI_STL_INTERNAL_CONSTRUCT_WJZH_H */

 // End