vector容器部分源码实现

STL中vector部分源码实现
本次作业要求自己模仿实现STL中vector部分函数

为了检测内存的管理机制是否是像源码一样，额外写了一个test类，通过输出来检测是否一样。
test代码如下：

#ifndef __TEST_H__
#define __TEST_H__

#include <memory>
#include <iostream>

class testAllocator : public std::allocator<int> {
    public:
    //这个函数用来申请内存，但是并不在上面创建新的变量，其中size是要申请的内存大小
        typedef std::allocator<int> Base;
        int * allocate(std::size_t size) {
            std::cout << "Test Allocator: allocate" << std::endl;
            return Base::allocate(size);        //调用了memory库中的allocate函数，下面同理
        }
    //这个函数用来释放内存，并不涉及调用在这片内存上面变量的析构函数，其中p是这片内存的首地址，size是这片地址的大小
        void deallocate(int * p, std::size_t size) {
            std::cout << "Test Allocator: deallocate" << std::endl;
            Base::deallocate(p, size);
        }
    //在已经申请了的内存上面创建一个新的变量，其中p是一个指针，指向我们要创建新的变量的地址，val是变量的值
        void construct(int * p, int val) {
            std::cout << "Test Allocator: Construct, value: " << val
                      << std::endl;
            Base::construct(p, val);
        }
    //在指针p指向的内存上，销毁掉变量，但是并不释放内存
        void destroy(int * p) {
            std::cout << "Test Allocator: Destroy, value: " << *p << std::endl;
            Base::destroy(p);
        }
};

#endif

为了防止一些人投机取巧使用#define myVector std::vector
所以额外写出了一个类base来防止这种情况

#ifndef __BASE_H__
#define __BASE_H__

#define vector NOT_ALLOWED
#define define NOT_ALLOWED

class Base {};

#endif

在类myVector中要继承自定义的Base，这样就可以防止#define myVector std::vector的情况
因为STL的vector是不可能继承自自定义的Base的，在测试函数中有一句是检查是否继承自Base

接下来放上具体代码，并解释其中一些写的过程中觉得比较难懂的知识点

//
//  vector.h:
//  C++
//
//  Created by 舒俊淮 on 16/5/22.
//  Copyright © 2016年 Shujh. All rights reserved.
//
#ifndef __VECTOR_H__
#define __VECTOR_H__
#define A Alloc()
#include "base.h"
#include "memory"
#include "test.h"
using namespace std;
/*typename Alloc = std::allocator<T>这是一个模板变量，类型名叫Alloc，接受分配器，如这里的testAllocator
“= std::allocator<T>”的意思是，默认调用T类型的allocator，比如写的是myVector<int>，没有提供第二个参数，就使用默认值*/
template< typename T, typename Alloc = std::allocator<T> >
class myVector : public Base {
 public:
    typedef T* iterator;
    typedef const T* const_iterator;
    myVector() {
/*这里用A.allocate()而不是直接allocate()的原因是allocate是一个类中的公共函数，不能直接调用
A.allocate()其实就是Alloc().allocate()先用Alloc()这个默认构造函数构造一个临时对象，之后在调用它的成员函数allocate()
这种做法是可行的，而且因为创建的是临时变量，这种做法是合理的*/
        _data = A.allocate(1);
        _capacity = 1;
        _size = 0;
    }
    myVector(const size_t &n, const T &ele, Alloc _A = Alloc()) {
//Alloc在这个例子被实例化成testAllocator，Alloc _A = Alloc()就是创建一个testAllocator对象
        _data = _A.allocate(n);
        _capacity = n;
        for (int i = 0; i < n; ++i)
            _A.construct(_data + i, ele);
        _size = n;
    }
    template<typename InputIterator>
    myVector(InputIterator begin, InputIterator end, Alloc _A = Alloc()) {
        _size = end - begin;
        _data = _A.allocate(_size);
        for (int i = 0; i < _size; ++i)
            _A.construct(_data + i, *(begin + i));
        _capacity = _size;
    }
    myVector(const myVector &other) {
        _size = other._size;
        _capacity = other._capacity;
        _data = A.allocate(_capacity);
        for (int i = 0; i < _size; ++i)
            A.construct(_data + i, *(other._data + i));
    }
    ~myVector() {
        if (_data) {
            for (int i = 0; i < _size; ++i)
                A.destroy(_data + i);
            A.deallocate(_data, _capacity);
        }
    }
    myVector & operator=(const myVector &other) {
        if (other._data != _data) {
            if (_data) {
                for (int i = 0; i < _size; ++i)
                    A.destroy(_data + i);
                A.deallocate(_data, _capacity);
            }
            _size = other._size;
            _capacity = other._capacity;
            _data = A.allocate(_capacity);
            for (int i = 0; i < _size; ++i)
                A.construct(_data + i, *(other._data + i));
        }
        return *this;
    }
    iterator begin() {return _data;}
    const_iterator begin() const {return _data;}
    iterator end() {return _data + _size;}
    const_iterator end() const {return _data + _size;}
    // Capacity
    size_t size() const {return _size;}
    void resize(const size_t &num) {
        if (num > _size) {
            if (num > _capacity) {
                int new_cap = _capacity * 2;
                while (new_cap < num)
                    new_cap *= 2;
                reserve(new_cap);
            }
            for (int i = _size; i < num; ++i)
                A.construct(_data + i, T());
            _size = num;
        } else {
            for (int i = num; i < _size; ++i)
                A.destroy(_data + i);
            _size = num;
        }
    }
    void resize(const size_t &num, const T &n) {
        if (num > _size) {
            if (num > _capacity) {
                int new_cap = _capacity * 2;
                while (new_cap < num)
                    new_cap *= 2;
                reserve(new_cap);
            }
            for (int i = _size; i < num; ++i)
                A.construct(_data + i, n);
            _size = num;
        } else {
            for (int i = num; i < _size; ++i)
                A.destroy(_data + i);
            _size = num;
        }
    }
    size_t capacity() const {return _capacity;}
    bool empty() const {return _size == 0 ? true : false;}
    void reserve(const size_t &newCap) {
        if (newCap > _capacity) {
            T* tmp = A.allocate(newCap);
            for (int i = 0; i < _size; ++i) {
                A.construct(tmp + i, _data[i]);
                A.destroy(_data + i);
            }
            A.deallocate(_data, _capacity);
            _capacity = newCap;
            _data = tmp;
        }
    }
    // Element Access
    T & operator[](const size_t &index) {
        if (index < _size) return *(_data + index);
    }
    const T & operator[](const size_t &index) const {
        if (index < _size) return *(_data + index);
    }
    T & front() {return *(_data);}
    const T & front() const {return *(_data);}
    T & back() {return *(_data + _size - 1);}
    const T & back() const {return *(_data + _size - 1);}
    T * data() {return _data;}
    const T * data() const {return _data;}
    // Modifiers
    template<typename InputIterator>
    void assign(InputIterator begin, InputIterator end) {
        clear();
        _size = end - begin;
        if (_size < _capacity) {
            for (int i = 0; i < _size; ++i)
                A.construct(_data + i, *(begin + i));
        } else {
            A.deallocate(_data, _capacity);
            _capacity = _size;
            _data = A.allocate(_capacity);
            for (int i = 0; i < _size; ++i)
                A.construct(_data + i, *(begin + i));
        }
    }
    void assign(const size_t &size, const T &n) {
        clear();
        _size = size;
        if (_size < _capacity) {
            for (int i = 0; i < _size; ++i)
                A.construct(_data + i, n);
        } else {
            A.deallocate(_data, _capacity);
            _capacity = _size;
            _data = A.allocate(_capacity);
            for (int i = 0; i < _size; ++i)
                A.construct(_data + i, n);
        }
    }
    void push_back(const T &n) {
        if (_size < _capacity) {
            A.construct(_data + _size, n);
            _size++;
        } else {
            int N = _size;
            int arr[N];
            for (int i = 0; i < _size; ++i)
                arr[i] = *(_data + i);
            A.deallocate(_data, _capacity);
            _capacity *= 2;
            _data = A.allocate(_capacity);
            for (int i = 0; i < _size; ++i)
                A.construct(_data + i, arr[i]);
            A.construct(_data + _size, n);
            _size++;
        }
    }
    void pop_back() {
        if (_size) {
            A.destroy(_data + _size - 1);
            _size--;
        }
    }
    void clear() {
        if (_size) {
            for (int i = 0; i < _size; ++i)
                A.destroy(_data + i);
            _size = 0;
        }
    }
 private:
    iterator _data;
    size_t _size, _capacity;
};
#endif

下面是测试函数：

#include <iostream>
#include "test.h"
#include "base.h"
#include "vector.h"

int main() {
    typedef myVector<int, testAllocator> v;
//这个函数，利用一个Base指针来检查myVector是否继承自Base，如若不是，那么便过不了编译
    Base * test = new v;
    delete static_cast<v *>(test);
    v * p1, * p2;
    int t;

    std::cout << "Test Constructor1:" << std::endl;
    p1 = new v;
    std::cout << "Size: " << p1->size() << std::endl;
    delete p1;

    std::cout << "Test Constructor2 and operator[]:" << std::endl;
    p1 = new v(static_cast<std::size_t>(6), 6);
    std::cout << "Size: " << p1->size() << std::endl;
    std::cout << "Content:";
    for (int i = 0; i < 2; ++i)
        std::cout << ' ' << (*p1)[i];
    std::cout << std::endl;
    std::cin >> t;
    std::cout << "Content after change:";
    (*p1)[0] = t;
    const v & r(*p1);
    for (int i = 0; i < 2; ++i)
        std::cout << ' ' << r[i];
    std::cout << std::endl;

    std::cout << "Test Constructor3 and iterators, including begin(), end():"
              << std::endl;
    p2 = new v(r.begin(), r.end());
    delete p1;
    std::cout << "Content:";
    for (v::iterator it = p2->begin(); it != p2->end(); ++it)
        std::cout << ' ' << *it;
    std::cout << std::endl;

    std::cout << "Test Constructor4:" << std::endl;
    *(p2->begin()) = 0;
    p1 = new v(*p2);
    delete p2;
    std::cout << "Content:";
    for (std::size_t i = 0; i < p1->size(); ++i)
        std::cout << ' ' << (*p1)[i];
    std::cout << std::endl;

    std::cout << "Test operator=:" << std::endl;
    p2 = new v(static_cast<std::size_t>(8), 8);
    *p2 = *p1;
    *p2 = *p2;
    delete p1;
    std::cout << "Content:";
    for (std::size_t i = 0; i < p2->size(); ++i)
        std::cout << ' ' << (*p2)[i];
    std::cout << std::endl;

    std::cout << "Test resize1:" << std::endl;
    p2->resize(2);
    std::cout << "Content:";
    for (std::size_t i = 0; i < p2->size(); ++i)
        std::cout << ' ' << (*p2)[i];
    std::cout << std::endl;

    std::cout << "Test resize2:" << std::endl;
    p2->resize(8, 8);
    std::cout << "Content:";
    for (std::size_t i = 0; i < p2->size(); ++i)
        std::cout << ' ' << (*p2)[i];
    std::cout << std::endl;

    std::cout << "Test reserve and capacity:" << std::endl;
    p2->reserve(33);
    std::cout << "Capacity: " << p2->capacity() << std::endl
              << "Size: " << p2->size() << std::endl;
    p2->reserve(2);
    std::cout << "Capacity: " << p2->capacity() << std::endl
              << "Size: " << p2->size() << std::endl;

    std::cout << "Test clear and empty:" << std::endl;
    if (p2->empty())
        std::cout << "True" << std::endl;
    else
        std::cout << "False" << std::endl;
    p2->clear();
    if (p2->empty())
        std::cout << "True" << std::endl;
    else
        std::cout << "False" << std::endl;
    std::cout << "Capcaity: " << p2->capacity() << std::endl
              << "Size: " << p2->size() << std::endl;

    int * arr = new int[5];
    for (int i = 0; i < 5; ++i)
        arr[i] = i+1;
    std::cout << "Test assign:" << std::endl;
    p2->assign(arr, arr+5);
    std::cout << "Content:";
    for (v::const_iterator it = p2->begin(); it != p2->end(); ++it)
        std::cout << ' ' << *it;
    std::cout << std::endl << "Size: " << p2->size()
              << std::endl << "Capacity: " << p2->capacity()
              << std::endl;

    delete [] arr;
    delete p2;
    return 0;
}

最后，说明一下在写的过程中个人比较迷惑最后弄懂了的知识点：
首先，一般来说出了作用域所有变量都会被析构。
而临时对象被析构的时间比较早，是在创建它的语句执行完之后，立刻被析构！
比如上面函数中的Alloc().allocate()，Alloc()是一个类的默认构造函数，它创建一个对象并且使用了类的成员函数allocate()。
执行完这个语句之后，这个刚刚被创建的对象就会被销毁。所以上面的代码不会出现类Alloc的对象堆积如山的情况。
为什么上面的代码要这么写呢？因为我们需要用到testAllocator这个类中的函数，又不想声明太多的testAllocator对象（很浪费），所以采用了临时变量的方法。

至于如何判断临时对象，一个简单的方法是看看它被构造之后有没有引用指向它，即，构造的时候有没有左值！
比如下面两行：
temp = Alloc();这里创建的不是一个临时变量，所以temp的析构是发生在退出作用域时。
Alloc();这个创建了一个临时变量，在执行完该语句之后立刻被析构。（调用析构函数~Alloc()）
还有一种情况是for语句，如：
for (int i = 0; i < 5; ++i) {}
在for语句执行完之后，临时变量i即被销毁。
下面是两个相关的例子，感受一下其中细微的差别：