【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();

下篇文章将剖析，内存的配置与释放，欢迎查看http://blog.csdn.net/always__/article/details/51240342