STL源码剖析读书笔记2

空间适配器allocator

为什么不说allocator是内存适配器而是空间适配器，原因就是你可以写
allocat直接向硬盘取空间。

allocator标准接口

设计一个简单的空间配置器JJ::allocator

_STD_BEGIN  
        // 这里是内存分配  
        // TEMPLATE FUNCTION _Allocate  
template<class _Ty> inline  
    _Ty _FARQ *_Allocate(_SIZT _Count, _Ty _FARQ *)  
    {   // allocate storage for _Count elements of type _Ty  
    void *_Ptr = 0;  

    if (_Count <= 0)  
        _Count = 0;  
    else if (((_SIZT)(-1) / sizeof (_Ty) < _Count)  
        || (_Ptr = ::operator new(_Count * sizeof (_Ty))) == 0)  
        _THROW_NCEE(bad_alloc, 0);  

    return ((_Ty _FARQ *)_Ptr);  
    }  

        // 使用 placement new 进行对象的拷贝构造放置  
        // TEMPLATE FUNCTION _Construct  
template<class _Ty1,  
    class _Ty2> inline  
    void _Construct(_Ty1 _FARQ *_Ptr, _Ty2&& _Val)  
    {   // construct object at _Ptr with value _Val  
    void _FARQ *_Vptr = _Ptr;  
    ::new (_Vptr) _Ty1(_STD forward<_Ty2>(_Val));  
    }  

        // 使用 placement new 进行对象的默认构造放置  
template<class _Ty1> inline  
    void _Construct(_Ty1 _FARQ *_Ptr)  
    {   // construct object at _Ptr with default value  
    void _FARQ *_Vptr = _Ptr;  

    ::new (_Vptr) _Ty1();  
    }  

        // 对象销毁（析构函数）  
        // TEMPLATE FUNCTION _Destroy  
template<class _Ty> inline  
    void _Destroy(_Ty _FARQ *_Ptr)  
    {   // destroy object at _Ptr  
    _Ptr->~_Ty();  
    }  

        // 内嵌字符串类型不用析构，特化版本供优化使用  
template<> inline  
    void _Destroy(char _FARQ *)  
    {   // destroy a char (do nothing)  
    }  

template<> inline  
    void _Destroy(wchar_t _FARQ *)  
    {   // destroy a wchar_t (do nothing)  
    }  

 #ifdef _NATIVE_WCHAR_T_DEFINED  
template<> inline  
    void _Destroy(unsigned short _FARQ *)  
    {   // destroy a unsigned short (do nothing)  
    }  
 #endif /* _NATIVE_WCHAR_T_DEFINED */  

        // 根据指针类型选择是否为 POD 数据类型  
        // TEMPLATE FUNCTION _Destroy_range  
template<class _Alloc> inline  
    void _Destroy_range(typename _Alloc::pointer _First,  
        typename _Alloc::pointer _Last, _Alloc& _Al)  
    {   // destroy [_First, _Last)  
    _Destroy_range(_First, _Last, _Al, _Ptr_cat(_First, _Last));  
    }  

        // 非 POD 数据类型需要显示调用析构函数  
template<class _Alloc> inline  
    void _Destroy_range(typename _Alloc::pointer _First,  
        typename _Alloc::pointer _Last, _Alloc& _Al,  
        _Nonscalar_ptr_iterator_tag)  
    {   // destroy [_First, _Last), arbitrary type  
    for (; _First != _Last; ++_First)  
        _Dest_val(_Al, _First);  
    }  

        // POD 数据类型不需要调用析构函数  
template<class _Alloc> inline  
    void _Destroy_range(typename _Alloc::pointer _First,  
        typename _Alloc::pointer _Last, _Alloc& _Al,  
        _Scalar_ptr_iterator_tag)  
    {   // destroy [_First, _Last), scalar type (do nothing)  
    }  

        // TEMPLATE FUNCTION addressof  
template<class _Ty> inline  
    _Ty * addressof(_Ty& _Val)  
    {   // return address of _Val  
    return ((_Ty *) &(char&)_Val);  
    }  

        // TEMPLATE CLASS _Allocator_base  
template<class _Ty>  
    struct _Allocator_base  
    {   // base class for generic allocators  
    typedef _Ty value_type;  
    };  

        // 偏特化，去除 const 属性  
        // TEMPLATE CLASS _Allocator_base  
template<class _Ty>  
    struct _Allocator_base<const _Ty>  
    {   // base class for generic allocators for const _Ty  
    typedef _Ty value_type;  
    };  

        // TEMPLATE CLASS _ALLOCATOR  
template<class _Ty>  
    class _ALLOCATOR  
        : public _Allocator_base<_Ty>  
    {   // generic allocator for objects of class _Ty  
public:  
    typedef _Allocator_base<_Ty> _Mybase;  
    typedef typename _Mybase::value_type value_type;  

    typedef value_type _FARQ *pointer;  
    typedef value_type _FARQ& reference;  
    typedef const value_type _FARQ *const_pointer;  
    typedef const value_type _FARQ& const_reference;  

    typedef _SIZT size_type;  
    typedef _PDFT difference_type;  

    // 由于在STL容器中allocator是以模板参数传入的，而对于节点型容器，

    template<class _Other>  
        struct rebind  
        {   // convert this type to _ALLOCATOR<_Other>  
        typedef _ALLOCATOR<_Other> other;  
        };  

    pointer address(reference _Val) const  
        {   // return address of mutable _Val  
        return ((pointer) &(char&)_Val);  
        }  

    const_pointer address(const_reference _Val) const  
        {   // return address of nonmutable _Val  
        return ((const_pointer) &(char&)_Val);  
        }  

    _ALLOCATOR() _THROW0()  
        {   // construct default allocator (do nothing)  
        }  

    _ALLOCATOR(const _ALLOCATOR<_Ty>&) _THROW0()  
        {   // construct by copying (do nothing)  
        }  

    // 这里使用了 Coercion by Member Template 惯用法  
    template<class _Other>  
        _ALLOCATOR(const _ALLOCATOR<_Other>&) _THROW0()  
        {   // construct from a related allocator (do nothing)  
        }  

    // 这里使用了 Coercion by Member Template 惯用法  
    template<class _Other>  
        _ALLOCATOR<_Ty>& operator=(const _ALLOCATOR<_Other>&)  
        {   // assign from a related allocator (do nothing)  
        return (*this);  
        }  

    // 内存释放  
    void deallocate(pointer _Ptr, size_type)  
        {   // deallocate object at _Ptr, ignore size  
        ::operator delete(_Ptr);  
        }  

    // 内存分配  
    pointer allocate(size_type _Count)  
        {   // allocate array of _Count elements  
        return (_Allocate(_Count, (pointer)0));  
        }  

    pointer allocate(size_type _Count, const void _FARQ *)  
        {   // allocate array of _Count elements, ignore hint  
        return (allocate(_Count));  
        }  

    void construct(pointer _Ptr, const _Ty& _Val)  
        {   // construct object at _Ptr with value _Val  
        _Construct(_Ptr, _Val);  
        }  

    // placement new  
    void construct(pointer _Ptr, _Ty&& _Val)  
        {   // construct object at _Ptr with value _Val  
        ::new ((void _FARQ *)_Ptr) _Ty(_STD forward<_Ty>(_Val));  
        }  

    template<class _Other>  
        void construct(pointer _Ptr, _Other&& _Val)  
        {   // construct object at _Ptr with value _Val  
        ::new ((void _FARQ *)_Ptr) _Ty(_STD forward<_Other>(_Val));  
        }  

    // 对象销毁  
    void destroy(pointer _Ptr)  
        {   // destroy object at _Ptr  
        _Destroy(_Ptr);  
        }  

    _SIZT max_size() const _THROW0()  
        {   // estimate maximum array size  
        _SIZT _Count = (_SIZT)(-1) / sizeof (_Ty);  
        return (0 < _Count ? _Count : 1);  
        }  
    };  

[1] placement new是重载operator new的一个标准、全局的版本，它不能被自定义的版本代替（不像普通的operator new和operator delete能够被替换成用户自定义的版本）。

它的原型如下：
void *operator new( size_t, void *p ) throw() { return p; }

使用方法如下：

1. 缓冲区提前分配

可以使用堆的空间，也可以使用栈的空间，所以分配方式有如下两种：

class MyClass {…};
char *buf=new char[N*sizeof(MyClass)+ sizeof(int) ] ;
或者char buf[N*sizeof(MyClass)+ sizeof(int) ];

1. 对象的构造

MyClass * pClass=new(buf) MyClass;

1. 对象的销毁

一旦这个对象使用完毕，你必须显式的调用类的析构函数进行销毁对象。但此时内存空间不会被释放，以便其他的对象的构造。

pClass->~MyClass();

1. 内存的释放

如果缓冲区在堆中，那么调用delete[] buf;进行内存的释放；如果在栈中，那么在其作用域内有效，跳出作用域，内存自动释放.

[2] size_t size=sizeof(i);//用sizeof操作得到变量i的类型的大小
ptrdiff_t diff=p2-p1;//指针的减法可以计算两个指针之间相隔的元素个数

[3]exit用在main内的时候无论main是否定义成void返回的值都是有效的，并且exit不需要考虑类型，exit⑴等价于return ⑴