allocator类的使用

allocator类是一个模板，它提供类型化的内存分配以及对象构造与撤销。allocator类将内存分配与对象构造分开。当allocator对象分配内存时，它分配适当大小并排列成保存给定类型对象的空间。但是，它分配的内存时未构造的，allocator用户必须分别construct和destroy放置在该内存中的对象。

下面通过实现一个动态数组说明allocator的使用。

#ifndef MYVECTOR_H
#define MYVECTOR_H
#include <memory>
#include <cstddef>
using namespace std;

template <class T>
class Vector
{
public:
    Vector(): elements(0), first_free(0), end(0) {}
    void push_back(const T&);
    void reserve(const size_t capa);

    //调整Vector大小，使其能容纳n个元素
    //如果n小于Vector当前大小，则删除多余元素
    //否则，添加采用值初始化的新元素
    void resize(const size_t n);

    //调整Vector大小，使其能容纳n个元素
    //所有新添加元素值都为t
    void resize(const size_t n, const T& t);

    //下表操作符
    T& operator[] (const size_t n);
    const T& operator[] (const size_t) const;

    //返回Vector大小
    size_t size()
    {
        return first_free-elements;
    }

    //返回Vector容量
    size_t capacity()
    {
        return end-elements;
    }

private:
    //用于获取未构造内存的对象
    static std::allocator<T> alloc;
    //获取更多空间并复制现有元素
    void reallocate();
    
    //指向第一个元素的指针
    T* elements;
    //指向第一个自由元素的指针
    T* first_free;
    //指向数组末端的下一个元素位置的指针
    T* end;
};

#endif

#include "Vector.hpp"

template <class T>
allocator<T> Vector<T>::alloc;

template <class T>
void Vector<T>::push_back(const T& t)
{
    if (first_free == end)
        //已用完所分配空间
        //获取更多空间，并复制现有元素至新分配空间
        reallocate();
    alloc.construct(first_free, t);
    ++first_free;
}

template <class T>
void Vector<T>::reallocate()
{
    //计算当前大小，并分配两倍于当前元素数的空间
    ptrdiff_t size = first_free - elements;
    ptrdiff_t newcapacity = 2*max(size, 1);

    //分配空间以保存newcapacity个T类的元素
    T* newelements = alloc.allocate(newcapacity);

    //在新空间构造现有元素的副本
    uninitialized_copy(elements, first_free, newelements);

    //逆序撤销旧元素
    for (T *p = first_free; p != elements; )
        alloc.destroy(--p);

    //不能用0值指针调用deallocate
    if (elements)
        //释放保存元素的内存
        alloc.deallocate(elements, end-elements);
    
    //使数据结构指向新元素
    elements = newelements;
    first_free = elements + size;
    end = elements + newcapacity;
}

template <class T>
void Vector<T>::reserve(const size_t capa)
{
    //计算当前数组大小
    size_t size = first_free-elements;
    //分配可保存capa个T类型元素的空间
    T *newelements = alloc.allocate(capa);
    //在新空间构造现有元素的副本
    if (size <= capa)
        uninitialized_copy(elements, first_free, newelements);
    else
        //如果capa小于原来数组的size，则去掉多余的元素
        uninitialized_copy(elements, elements+capa, newelements);

    //逆序撤销旧元素
    for (T *p = first_free; p != elements; )
        alloc.destroy(--p);

    if (elements)
        //释放旧元素所占内存
        alloc.deallocate(elements, end-elements);

    //使数据结构指向新元素
    elements = newelements;
    first_free = elements + min(size, capa);
    end = elements + capa;
}

template <class T>
void Vector<T>::resize(const size_t n)
{
    //计算当前大小及容量
    size_t size = first_free - elements;
    size_t capacity = end - elements;

    if (n > capacity)
    {
        reallocate();
        uninitialized_fill(elements+size, elements+n, T());
    }
    else if (n > size)
    {
        uninitialized_fill(elements+size, elements+n, T());
    }
    else
    {
        for (T *p = first_free; p != elements; )
            alloc.destroy(--p);
    }
    first_free = elements + n;
}

template <class T>
void Vector<T>::resize(const size_t n, const T& t)
{
    size_t size = first_free - elements;
    size_t capacity = end - elements;

    if (n > capacity)
    {
        reallocate();
        uninitialized_fill(elements+size, elements+n, t);
    }
    else if (n > size)
    {
        uninitialized_fill(elements+size, elements+n, t);
    }
    else
    {
        for (T *p = first_free; p != elements; )
            alloc.destroy(--p);
    }
    first_free = elements+n;
}

template <class T>
T& Vector<T>::operator[] (const size_t index)
{
    return elements[index];
}

template <class T>
const T& Vector<T>::operator[] (const size_t index) const
{
    return elements[index];
}

#include <iostream>
#include <string>
#include "Vector.hpp"
#include "Vector.cpp"
using namespace std;


int main()
{
    Vector<int> ivec;
    for (size_t i = 0; i != 8; ++i)
    {
        ivec.push_back(i);
        cout << ivec[i] << "	";
    }
    cout << endl;

    cout << ivec.size() << "	" << ivec.capacity() << endl;
    ivec.reserve(50);
    cout << ivec.size() << "	" << ivec.capacity() << endl;
    ivec.resize(20);
    for (size_t i = 0; i != 20; ++i)
        cout << ivec[i] << "	";
    cout << endl;

    cout << ivec.size() << "	" << ivec.capacity() << endl;
    cout << ivec[2] << "	" << ivec[10] << endl;


    return 0;
}