【STL】空间配置器剖析（一）

最近看了看侯捷的《STL源码剖析》，打算看完之后写写笔记，毕竟很多东西看起来看懂了，却并不一定能够将其描述清楚，说到底还是没有彻底弄明白，更主要是写给自己看的，记录一下，以便以后再看。

SGI标准的空间配置器是std::allocator。SGI从未使用过它，也不建议使用它，主要原因是效率不佳。

SGI特殊的空间配置器，std::alloc，对于标准的std::allocator它只是简单的包装了operator new 和operator delete。并没有效率的问题，SGI则另有办法。如下介绍

STL allocator决定将内存配置操作的由alloc::allocate()负责，内存释放操作由alloc:: deallocate来管理，对象的构造由construct（）负责，对象的析构由destory（）负责。

配置器定义于<memory>中，SGI<memory>中含有:

#include<stl_alloc.h>

#include<stl_construct.h>

这是《STL源码剖析》对于空间配置器的大致框架，值得参考







本文主要讲的是stl_construct.h中，内存配置后的对象构造行为和内存释放前的对象析构行为！

下面先从一个简单的allocator源码看起：

#ifndef _JJALLOC_
#define _JJALLOC_

#include <new>
#include <cstddef>
#include <cstdlib>
#include <climits>
#include <iostream>

namespace JJ
{
// 使用operator new分配空间
template<class T>
inline T* _allocate(ptrdiff_t size, T*)
{
std::set_new_handler(0);
T *tmp = (T*)(::operator new((size_t)(size * sizeof(T))));
if (tmp == 0)
{
std::cerr << "out of memory" << std::endl;
exit(1);
}
return tmp;
}
// 使用operator delete回收空间
template<class T>
inline void _deallocate(T* buffer)
{
::operator delete(buffer);
}
// 在指定内存上构造一个对象
template<class T1, class T2>
inline void _construct(T1* p, const T2& value)
{
// placement new
new (p) T1(value);
}
// 析构一个对象
template<class T>
inline void _destroy(T* ptr)
{
ptr->~T();
}
// 遵循allocator的标准定义相关结构
template<class T>
class allocator
{
public:
typedef T           value_type;
typedef T*          pointer;
typedef const T*    const_pointer;
typedef T&          reference;
typedef const T&    const_reference;
typedef size_t      size_type;
typedef ptrdiff_t   difference_type;

template<class U>
struct rebind
{
typedef allocator<U> other;
};

pointer allocate(size_type n, const void* hint=0)
{
return _allocate((difference_type)n, (pointer)0);
}

void deallocate(pointer p, size_type n)
{
_deallocate(p);
}

void construct(pointer p, const T& value)
{
_construct(p, value);
}

void destroy(pointer p)
{
_destroy(p);
}

pointer address(reference x)
{
return (pointer)&x;
}

const_pointer const_address(const_reference x)
{
return (const_pointer)&x;
}

size_type max_size() const
{
return size_type(UINT_MAX/sizeof(T));
}
};
}

#endif

上面的代码之中的几个点：

1. set_new_handler

set_new_handler的函数原型如下：

typedef void (*new_handler)();
new_handler set_new_handler (new_handler new_p) throw();

使用set_new_handler可以设置一个函数new_p，当使用new/operator new分配内存失败时，new_p将被调用。new_p将尝试使得更多内存空间可用，以使得接下来的内存分配操作能够成功。如果new_p指向NULL（默认就是NULL），那么将会抛出bad_alloc异常，这也是为什么我们默认使用new失败的时候将会抛出bad_alloc异常的原因；

2. 几个new/delete操作

我们使用的new叫做new operator，包括两个步骤，一是调用operator new来分配指定大小的内存空间，然后调用构造函数；所以如果只是进行空间分配操作，那么使用operator new就可以了，就好比C的malloc函数；如果已经分配好了空间，想在上面构造一个对象，那么可以使用placement new，上面的_construct函数里面调用的就是placement new；

下面贴上#include<stl_construct.h>代码：这个头文件中定义了构造和析构的相关函数。

// 调用placement new，根据__value在__p上构造一个对象
template <class _T1, class _T2>
inline void _Construct(_T1* __p, const _T2& __value) {
new ((void*) __p) _T1(__value);
}

// 调用placement new在__p上构造一个对象，使用默认构造函数
template <class _T1>
inline void _Construct(_T1* __p) {
new ((void*) __p) _T1();
}

// 析构一个对象
template <class _Tp>
inline void _Destroy(_Tp* __pointer) {
__pointer->~_Tp();
}

// 析构迭代器__first和__last之间的对象，实际上通过destroy函数，调用了对应的析构函数
template <class _ForwardIterator>
void
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
{
for ( ; __first != __last; ++__first)
destroy(&*__first);
}

// __destroy_aux重载函数，这里是对于trivial析构函数，不进行任何处理，提高效率
template <class _ForwardIterator>
inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}

// 根据__type_traits萃取出类型_Tp的析构函数是否是trivial的，编译器根据类型自动选择对应的__destroy_aux
template <class _ForwardIterator, class _Tp>
inline void
__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
{
typedef typename __type_traits<_Tp>::has_trivial_destructor
_Trivial_destructor;
__destroy_aux(__first, __last, _Trivial_destructor());
}

template <class _ForwardIterator>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
__destroy(__first, __last, __VALUE_TYPE(__first));
}

inline void _Destroy(char*, char*) {}
inline void _Destroy(int*, int*) {}
inline void _Destroy(long*, long*) {}
inline void _Destroy(float*, float*) {}
inline void _Destroy(double*, double*) {}
#ifdef __STL_HAS_WCHAR_T
inline void _Destroy(wchar_t*, wchar_t*) {}
#endif /* __STL_HAS_WCHAR_T */

// --------------------------------------------------
// Old names from the HP STL.

template <class _T1, class _T2>
inline void construct(_T1* __p, const _T2& __value) {
_Construct(__p, __value);
}

template <class _T1>
inline void construct(_T1* __p) {
_Construct(__p);
}

template <class _Tp>
inline void destroy(_Tp* __pointer) {
_Destroy(__pointer);
}

template <class _ForwardIterator>
inline void destroy(_ForwardIterator __first, _ForwardIterator __last) {
_Destroy(__first, __last);
}

__STL_END_NAMESPACE

这里值得一提的主要是析构部分使用的一些技巧。首先解释一下所谓的trivial destructor，默认的析构函数，一般没有什么重要东西，而no-trivial destructor则指的是自定义的析构函数，可能在析构函数中，程序员加入了某种机制。那么处于效率方面的考虑，在这样的情况下（rivial
destructor，默认的析构函数）肯定选择什么都不做（如果进行十万百万次这样的函数调用，是不是就白白浪费了大好的时光了？）而且这里是在编译器就通过函数的重载来决定是否要调用析构函数。

具体是通过__type_traits来萃取出类型是否具有trivial destructor的，这里在后面的文章会提到这些细节。现在所要了解的就是通过__type_traits可以萃取出类型的destructor特性（trivial or non-trivial），然后通过函数重载来决定具体进行什么样的操作。

总结一下：

stl_construct.h 中主要进行对象的创建和析构，construct()接受一个指针和一个初值，该函数的用途就是将初值设定到指针所指的空间上，c++的placement new运算符可以实现。

destory()有两个实现版本，第一个版本接受一个指针，析构指针的指向，直接调用该对象的析构函数即可，第二个版本接受迭代器的范围，将区间内的对象析构，我们无法知道这个范围有多大，当每个析构函数是trivial destructor时，不用每次都去调用，提高效率。但若果是自定义的non-trivial
destructor。则必须每经历一个对象，释放一次。因此，这里我们首先用value_type()获得迭代器的所值对象的型别，再利用_type_traits<T>判断该型别的析构函数是不是自定义的，若是（_destory代码中的第三个参数为_true_type）,则什么也不做，否则（_false_type）,这才以循环的方式访问整个范围，每经历一个对象，就调用第一个版本的destory();

下篇文章将剖析，内存的配置与释放，欢迎查看/article/7809407.html