实现一个简单的空间配置器

根据STL的标准，配置器的必要接口有：

//allocator 必要的接口

allocator::value_type        // 值类型
allocator::pointer           // 指针类型
allocator::const_pointer     // 常量指针类型
allocator::reference         // 引用
allocator::const_reference    // 常量引用 
allocator::size_type         // 大小的类型
allocator::difference_type    // 不同的类型

实现一个空间配置器：

 // 在“zjpalloc.h”文件
 #ifndef _ZJPALLOC_
 #define _ZJPALLOC_
 #includes<new> // for palcement new
 #include<cstddef>  // for ptrdiff_t,size_t
 #include<cstdlib>  // for exit()
 #include<climits>  // for UINT_MAX
 #include<iostream> // for cerr

 namespace ZJP
 {
     // 内存分配函数
     template<class T>
     inline T* _allocate(ptrdiff_t size,T*){
         set_new_handler(0);    // C++的new handler机制，你可以要求系统在内存配置需求无法被满足时，调用一个你所指定的函数
         T* tmp=(T*)(::operator new((size_t)(size*sizeof(T))));     // 调用了全局的operator new() 分配所需类型变量的内存字节数
         if(tmp==0){        // 分配内存失败，报错
             cerr<<"out of memory"<<endl;
             exit(1);
         }
         return tmp;
     }

     // 释放内存的函数
     template<class T>
     inline void _deallocate(T* buffer){
         ::operator delete(buffer);     // 调用全局的operator delete()
     }

     // placement new，内存重新构造利用，构造的类型是第二个参数的类型，重新利用的内存指针是第一个参数的类型
     template<class T1,class T2>
     inline void _construct(T1* p,const T2& value){
         new(p) T1(value);
     }

     // 封装析构函数
     template<class T>
     inline void _destroy(T* ptr){
         // 调用·自主类型的析构函数
         ptr->~T();
     }

     // 写一个分配器的类：封装上述写的各个函数
     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;

            // 一个嵌套的class templat，放置的是其他类型的
            template<class U>
            struct rebind{
                typedef allocator<U> other;
            };

            // 分配器构造函数
            pointer allocator(size_type n,const void* hint=0){
                return _allocate((difference_type)n,(pointer)0);
            }

            // 分配器的释放内存
            void deallocate(pointer p,size_type n){
                _deallocate(p);
            }

            // palcement new重新构造
            void construct(pointer p,size_type value){
                _construct(p,value);
            }

            // 析构函数
            void destroy(pointer p){
                _destroy(p);
            }

            // 调用a.address(x)：相当于&x(取地址)
            pointer address(reference x){
                return (pointer)&x;
            }

            // 返回常量指针
            const_pointer const_address(const_reference x){
                return (const_pointer)&x;
            }

            // 通过unsigned int算出最大个数
            size_type max_size() const{
                return size_type(UINT_MAX/sizeof(T));
            }
     };

 }  // end of namespace ZJP

 #endif     // _ZJPALLOC_

---

调用的时候可以这样写测试程序：

#include"zjpalloc.h"
#include<iostream>
#include<vector>
using namespace std;

void test(){
    int a[5]={0,1,2,3,4};
    unsigned int i;

    vector<int,ZJP::alloctor<int>>vec(a,a+5);
    for(int i=0;i<vec.size();i++){
        cout<<vec[i]<<" ";
    }
    cout<<endl;
}

int main(){
    test();
    return 0;
}