STL源码剖析笔记1.1 简单的空间配置器allocator

空间配置器allocator应用在STL一切容器之后，而整个STL的操作对象都要存放在容器中来工作，所以空间配置器是整个STL最基本的组件。

根据STL规范标准接口设计一个简单的空间配置器 HS::allocator

#include <new>
#include <cstddef>
#include <cstdlib>
#include <climits>
#include <iostream>
using std::set_new_handler;
using std::cerr;

namespace HS
{
    template <class T>
    inline T* _allocate(ptrdiff_t size, T*)
    {
        set_new_handler(0);
        T* tmp = (T*) (::operator new((size_t)(size * sizeof(T))));
        if (tmp == 0)
        {
            cerr << "out of memory\n";
            exit(1);
        }
        return tmp;
    }

    template <class T>
    inline void _deallocate(T* buffer)
    {
        ::operator delete(buffer);
    }

    template <class T1, class T2>
    inline void _construct(T1* p, const T2& value)
    {
        new(p) T1(value);   // placement new. invoke ctor of T1
    }

    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;

        // rebind allocator of type U
        template <class U>
        struct rebind
        {
            typedef allocator<U> other;
        };

        //hint used for locality
        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));
        }
    }; // end of class allocator
} // end of namespace HS

将allocator应用到STL vector等容器中简单测试如下

#include <iostream>
#include "HS_allocator.h"
#include <vector>
using namespace std;
int main()
{
    int ia[5] = {0, 1, 2, 3, 4};

    vector<int, HS::allocator<int> > iv(ia, ia+5);
    for(unsigned int i=0; i<iv.size(); i++)
        cout << iv[i] << " ";
    cout << endl;
    return 0;
}