自己动手实现STL 02：构造析构的基本工具construct()和destroy()(stl_construct.h)
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
一、前言
上一篇，我先完成了对内存配置器的实现。然而后面在内存上的算法还依赖于两个全局函数，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
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |