侯捷STL课程及源码剖析学习2: allocator

　　以STL 的运用角度而言，空间配置器是最不需要介绍的东西，它总是隐藏在一切组件（更具体地说是指容器，container）的背后，默默工作默默付出。

一、分配器测试

测试代码

 #include <list>
 #include <stdexcept>
 #include <string>
 #include <cstdlib>         //abort()
 #include <cstdio>          //snprintf()
 #include <algorithm>     //find()
 #include <iostream>
 #include <ctime> 

 #include <cstddef>
 #include <memory>    //内含 std::allocator
 //欲使用 std::allocator 以外的 allocator, 得自行 #include <ext\...>
 #ifdef __GNUC__
 #include <ext\array_allocator.h>
 #include <ext\mt_allocator.h>
 #include <ext\debug_allocator.h>
 #include <ext\pool_allocator.h>
 #include <ext\bitmap_allocator.h>
 #include <ext\malloc_allocator.h>
 #include <ext\new_allocator.h>
 #endif

 namespace jj20
 {
     //pass A object to function template impl()，
     //而 A 本身是个 class template, 带有 type parameter T,
     //那么有无可能在 impl() 中抓出 T, 创建一个 list<T, A<T>> object?
     //以下先暂时回避上述疑问.

     void test_list_with_special_allocator()
     {
 #ifdef __GNUC__
         cout << "\ntest_list_with_special_allocator().......... \n";

         //不能在 switch case 中宣告，只好下面这样.                 //1000000次
         list<string, allocator<string>> c1;                        //
         list<string, __gnu_cxx::malloc_allocator<string>> c2;      //
         list<string, __gnu_cxx::new_allocator<string>> c3;         //
         list<string, __gnu_cxx::__pool_alloc<string>> c4;          //
         list<string, __gnu_cxx::__mt_alloc<string>> c5;         //
         list<string, __gnu_cxx::bitmap_allocator<string>> c6;      //4781                                                         

         int choice;
         long value;

         cout << "select: "
             << " (1) std::allocator "
             << " (2) malloc_allocator "
             << " (3) new_allocator "
             << " (4) __pool_alloc "
             << " (5) __mt_alloc "
             << " (6) bitmap_allocator ";

         cin >> choice;
         if (choice != ) {
             cout << "how many elements: ";
             cin >> value;
         }

         char buf[];
         clock_t timeStart = clock();
         for (long i = ; i< value; ++i)
         {
             try {
                 snprintf(buf, , "%d", i);
                 switch (choice)
                 {
                 case :     c1.push_back(string(buf));
                     break;
                 case :     c2.push_back(string(buf));
                     break;
                 case :     c3.push_back(string(buf));
                     break;
                 case :     c4.push_back(string(buf));
                     break;
                 case :     c5.push_back(string(buf));
                     break;
                 case :     c6.push_back(string(buf));
                     break;
                 default:
                     break;
                 }
             }
             catch (exception& p) {
                 cout << "i=" << i << " " << p.what() << endl;
                 abort();
             }
         }
         cout << "a lot of push_back(), milli-seconds : " << (clock() - timeStart) << endl;

         //test all allocators' allocate() & deallocate();
         int* p;
         allocator<int> alloc1;
         p = alloc1.allocate();
         alloc1.deallocate(p, );

         __gnu_cxx::malloc_allocator<int> alloc2;
         p = alloc2.allocate();
         alloc2.deallocate(p, );

         __gnu_cxx::new_allocator<int> alloc3;
         p = alloc3.allocate();
         alloc3.deallocate(p, );

         __gnu_cxx::__pool_alloc<int> alloc4;
         p = alloc4.allocate();
         alloc4.deallocate(p, );     //我刻意令参数为 2, 但这有何意义!! 一次要 2 个 ints? 

         __gnu_cxx::__mt_alloc<int> alloc5;
         p = alloc5.allocate();
         alloc5.deallocate(p, );

         __gnu_cxx::bitmap_allocator<int> alloc6;
         p = alloc6.allocate();
         alloc6.deallocate(p, );      //我刻意令参数为 3, 但这有何意义!! 一次要 3 个 ints?
 #endif
     }
 }

注：直接使用分配器allocate时，释放时须指明释放内存大小。

二、简单的内存分配器

一般而言，c++的内存分配和释放是这样操作的

class Foo{ //...};
Foo* pf = new Foo;//配置内存，然后建构对象
delete pf; //将对象解构，然后释放内存

　　其中的 new操作内含两阶段动作：(1)调用::operator new配置内存，(2) 调用Foo::Foo()建构对象内容。delete操作也内含两阶段动作： (1)调用Foo::~Foo()将对象解构，(2)调用::operator delete释放内存。

　　为了精密分工，STL allocator决定将这两阶段区分开来。内存配置由alloc:allocate()负责，内存释放由alloc::deallocate()负责； 对象建构由::construct()负责，对象析构由::destroy()负责。

简单内存分配器代码

 #ifndef SIMPLE_JJALLOC_H
 #define SIMPLE_JJALLOC_H
 #include<new>         //for placement new
 #include<cstddef> //for ptrdiff_t,size_t
 #include<cstdlib> //for exit()
 #include<climits> //for UINT_MAX十进制的最大值
 #include<iostream>    //for cerr  

 namespace JJ
 {
     /*****************ptrdiff_t与size_t类型*****size_type与difference_type类型********************
     ****ptrdiff_t:signed类型，通常用于两指针减法操作的结果，它可以是负数。（因为指针相减有正有负）
     ****size_t:unsigned类型，用于指明数组长度，它是非负整数。
     ****size_type:unsigned类型，容器中元素长度或下表，vector<int>::size_type i=0;
     ****difference_type:signed类型，表示迭代器差距，vector<int>::difference_type=iter1-iter2
     ****前两者位于标准类库std内，后两者为stl对象所有
     *********************************************************************************************/
     template<class T>
     inline T* _allocate(ptrdiff_t size, T*)
     {
         std::cout<<"I'm _allocate in simple_jjalloc!"<<std::endl;
         /**************************new_handler与set_new_handler***********************************
         ****new_handler:内存分配失败后，调用的处理函数。
         ****set_new_handler:参数是被指定的new_handler函数指针，返回参数也是new_handler是被替换掉的new_handler
         *****************************************************************************************/
         std::set_new_handler();
         /****************::***********************************************************************
         ****"::":全局作用。比如::luo这就是个全局变量，而luo这是个局部变量
         ****"::":类作用。比如Node::function()
         ****"::":名字空间。比如std::size_t
         *****************************************************************************************/
         T *tmp=(T*)(::operator new((size_t)(size*sizeof(T))));
         if(tmp == )//没有前面的std::set_new_handler(0);把内存分配失败后的异常调用函数给替换掉，就执行不到这儿
         {
             std::cout<<"failed!"<<std::endl;
             std::cerr<<"out of memory"<<std::endl;
             exit();
         }
         return tmp;
     }  

     template<class T>
     inline void _deallocate(T* buffer)
     {
         ::operator delete(buffer);
     }
     /************************************new的三种形态*******************************************
     ****new operator:就是平常用的new，通常做三件事，1.用operator new分配内存给对象，2.调用构造函数初始化那块内存，3.将地址转给对象指针
                      如果仅仅是在堆上建立对象，那么应该使用new operator，它会提供周全的服务
     ****operator new:在默认情况下首先会调用分配内存的代码，尝试从堆上得到一段空间，成功就返回，失败就调用new_hander，重复前面过程，直到抛出异常
                      如果仅仅是分配内存，那么应该调用operator new，但初始化不在它的职责之内。若对默认的内存分配过程不满意，那就重载它
     ****placement new:用来实现定位构造，可以通过它来选择合适的构造函数。
                      如果想在一块已获得的内存里建立一个对象，那就改用placement new
     ********************************************************************************************/
     template<class T1,class T2>
     inline void _construct(T1* p,const T2& val)
     {
         new(p) T1(val);//p为那块内存地址，T1()为指定构造函数；此句为p->T1::T1(val);
         std::cout<<"I'm _construct!"<<std::endl;
     }  

     template<class T>
     inline void _destroy(T* ptr)
     {
         std::cout<<"I'm _destroy!"<<std::endl;
         ptr->~T();
     }  

     template<class T>
     class mallocator
     {
         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 mallocator<U> mother;
             };   

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

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

             void construct(pointer p,const_reference val)
             {
                 _construct(p,val);
             }  

             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(value_type));
             }
     };
 }
 #endif 

内存分配测试代码：

int ia[5] = {1,2,3,4,5};

vector<int,JJ::mallocator<int>> iv(ia,ia+3);

for (auto i : iv)
cout<<i<<" ";
cout<<endl;

测试结果

I'm _allocate in simple_jjalloc!
I'm _construct!
I'm _construct!
I'm _construct!
1 2 3
I'm _destroy!
I'm _destroy!
I'm _destroy!

直接使用allocate, 不用new. 代码环境GNU 2.9 ，高版本头文件找不到。

 #include<iostream>
 #include<defalloc.h>
 #include<stl_alloc.h>
 using namespace std;
 void main()
 {
     void* p = allocator<int>().allocate();
     allocator<int>().deallocate((int*)p);
     cout << "allocator<int>().allocate(512);"<<endl;

     void* p2 = alloc::allocate();
     alloc::deallocate(p2, );

     cout << "allocate(512, 0);" << endl;
 }

二、 OOP(Object-Oriented Programming) vs GP(Generic Programming)

　　OOP是将数据和方法封装在一起，多采用继承和多态。

　　GP却是将datas 和 methods 分开来。如STL中，Container 和 Algorithms 可以各自独立进行开发，两者使用迭代器进行关联。Algorithms通过iterators 确定操作范围，并获取容器元素。

深入理解留待后续。。。

内容参考：

侯捷STL课程, 《STL源码剖析》