STL源码分析之空间配置器

前言

SGI STL将new的申请空间和调用构造函数的两个功能分开实现, 如果对new不太清楚的, 可以先去看看这一篇new实现再来看配置器也不迟. 本节是STL分析的第一篇, 主要分析STL各个部分都会出现的alloc实现, 虽然每个部分都只会默认调用它, 不了解它也可以看懂分析, 但是他又是不可缺少的, 我们就以它做为开篇进行分析.

"new"的实现

这里直接我们直接来看STL的construct实现吧

   // 这里的construct调用的是placement new, 在一个已经获得的内存里建立一个对象
   template <class T1, class T2>
   inline void construct(T1* p, const T2& value)
   {
     new (p) T1(value);
   }

可以明白这里就只是一个placement new的调用, 只是用了泛型来实现一个对象分配的模板, 并实现初始化.

既然已经看到了对象的分配, 那再接再厉看看空间的分配, 充分了解STL是怎么将new分开执行的. allocate函数实现空间的申请, 但是这里有一点看不出来, 申请内存是有分为一级配置器和二级配置器, 分配的空间小于128字节的就调用二级配置器, 大于就直接使用一级配置器, 一级配置器直接调用malloc申请, 二级使用内存池.

   template<class T>
   inline T* allocate(ptrdiff_t size, T*)
   {
       set_new_handler();
       T* tmp = (T*)(::operator new(size)(size * sizeof(T)));
       if(!tmp)
       {
           cerr << "out of memort" << endl;
           exit();
       }
       return tmp;
   }

内存分配果然是调用operator new来执行空间分配, 这里allocate和construct都只是简单的对operator new进行封装.

   const int N = ;
   int main()
   {
       allocator<string>  alloc;
       auto str_ve = alloc.allocate(N);
       auto p = str_ve;    // vector<string> *p = str_ve;
       alloc.construct(p++);
       alloc.construct(p++, , 'a');
       alloc.construct(p++, "construct");
       cout << str_ve[] << endl; //  " "空的
       cout << str_ve[] << endl; // aaaaaaaaaa
       cout << str_ve[] << endl; // construct

       while(p != str_ve)
       {
           alloc.destroy(--p);
       }
       alloc.deallocate(str_ve, N);
   ​
       exit();
   }

这个程序首先调用allocate申请N个大小的空间, 在依次construct调用构造函数, 这里就先初始化3个结构, 紧接着通过destory调用析构函数, 最后deallocate释放申请的空间. 整个过程很容易理解, 但是这里还要深入是dealllocate和destroy两个函数.

"delete"实现

先是看destroy调用析构函数. 而destroy有两个版本.

版本一:

需要传入的参数 : 一个指针

  // 第一版本, 接收指针
  template <class T> inline void destroy(T* pointer)
  {
      pointer->~T();
  }

版本一直接就调用了析构函数, 不用过多的分析.

版本二:

需要传入的参数 : 两个迭代器

  // 第二个版本的, 接受两个迭代器, 并设法找出元素的类型. 通过__type_trais<> 找出最佳措施
  template <class ForwardIterator>
  inline void destroy(ForwardIterator first, ForwardIterator last)
  {
    __destroy(first, last, value_type(first));
  }
  ​
  // 接受两个迭代器, 以__type_trais<> 判断是否有traival destructor
  template <class ForwardIterator, class T>
  inline void __destroy(ForwardIterator first, ForwardIterator last, T*)
  {
    typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
    __destroy_aux(first, last, trivial_destructor());
  }

destroy直接调用 __destroy, 前者只是一个接口, 所以重点是在后者.

分析 __type_traits<> : 它是用于获取迭代器所指对象的类型,运用traits技法实现的.只要记住我们用来获取对对象类型就可以了. 然后通过类型的不一样选择执行不同的析构调用.

当__type_traits为__false_type时, 调用的是下面这个函数, 通过迭代所有的对象并调用版本一的函数执行析构函数进行析构. 而这个是被称为non-travial destructor

  // 没有non-travial destructor
  template <class ForwardIterator>
  inline void __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type)
  {
    for ( ; first < last; ++first)
      destroy(&*first);
  }

当__type_traits为__true_type时, 什么也不做, 因为这样效率很高效, 并不需要执行析构函数. 而这个是被称为travial destructor.

  // 有travial destructor
  template <class ForwardIterator>
  inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {}

最后是版本二的特化版, 同样也什么都不用做, 没有必要做析构.

  inline void destroy(char*, char*) {}
  inline void destroy(wchar_t*, wchar_t*) {}

destroy分为这么几个版本和几个不同的函数执行都是为了提升效率, 较小的调用并不能看出什么, 但是如果是范围析构的话这样不同的选择析构能很节约时间和效率.

讲解完了destory后应该就能明白上面代码循环执行析构函数了.

---

小结

这里用一个小小的例子来理解"new"和"delete"运算符, 理解new, delete每步分开执行, 内存释放(deallocate)这里没有讲解, 也只是简单的调用free函数. STL这样做1. 为了效率, 2. 为了构建内存池.

最后将所有的函数进行封装到allocator, 所以例子中都是调用的构造析构等都是封装在该类中.