vector的自定义实现

#pragma warning(disable:4996)
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<complex>
#include<new>
#include<memory>
#include<exception>
#include<cstdlib>
#include<iterator>
#include<initializer_list>
using namespace std;
//template<typename t> class alloc
//{public:
//    alloc():a(),s(){ //成员变量默认初始化
//    }
//    t* allocate(size_t n){
//        return a.allocate(n);
//    }
////变长模板参数，allocator的第二个参数是变长的，要调用它，外层的construct也要有变长参数
//template<typename...Args>    void construct(t* p, const Args&...rest){
//        a.construct(p,rest... );
//    }
//    void deallocate(t* p, size_t n)
//    {
//        a.deallocate(p, n);
//    }
//    void destory(t* p)
//    {
//        a.destory(p);
//    }    
//
//
//private:
//    allocator<t> a;
//    string s;
//    
//};
//vector为空，capacity=0,否则预分配空间为16，当空间不足时，扩大两倍增长，
template<typename T, class Allocator = std::allocator<T> >
class Vector{
private:
    T* start;
    T* finish;
    T* end_of_storage;
    size_t length;
    size_t capacity;
public:
    typedef T* iterator;
    typedef const T* const_iterator;
    Vector():start(NULL),finish(0){ 
    end_of_storage = NULL;
    length = 0;
    capacity = 0;
    } 
    Vector(const std::initializer_list<T> &lst)
    {    
        for (auto it = lst.begin(); it != lst.end();it++)
        {
            this->push_back(*it);
        }
        
    }
    Vector(size_t n, const T&value = T()){
        Allocator a;
        T*p = NULL;
        if (n <= 16){ p = a.allocate(16); 
        capacity = 16;
        }
        else {
            p = a.allocate(static_cast<int>(1.5 * n));
            capacity = static_cast<size_t>(1.5*n);
        }
        start = p;
        finish=uninitialized_fill_n(p, n, value);
        if (n <= 16) end_of_storage = start + 15;
        else     end_of_storage = p + static_cast<int>(1.5*n)-1;
        length = n;
    } 
    /*Vector(size_t n, const T&value){ Vector(n, value); }*/
    Vector(const Vector& rhs){
        capacity = rhs.capacity;
        length = rhs.length;
        Allocator a;
        start=a.allocate(capacity);
        end_of_storage = start + capacity - 1;
        finish = start + length ;
        
        for (T* p = start,*q = rhs.start; p != finish; p++, q++){
            a.construct(p, *q);
        }
    }
    void push_back(const T& value){
        if (capacity == 0){ //为空容器时需要申请新空间
            Allocator a;
             start = a.allocate(16);
            a.construct(start, value);
            finish = start + 1;
            end_of_storage = start + 15;
            length = 1;
            capacity = 16;
        }
        else if (length < capacity){
            Allocator a;
            a.construct(finish++, value);
            length += 1;
        }
        else { //空间不足时1.5倍扩大空间
            Allocator a;
            auto old_capacity = capacity;
            auto new_start = a.allocate(static_cast<size_t>(1.5*capacity));
            auto new_finish = uninitialized_copy(this->begin(), this->begin()+length, new_start); //没有使用迭代器形式
            new_finish = uninitialized_fill_n(new_finish, 1, value);
            //释放掉旧空间
            capacity = static_cast<size_t>(1.5*capacity);
            length += 1;
            
            auto temp = start;
            while (temp != finish)
            {
                a.destroy(temp++);
            }
            a.deallocate(start, old_capacity);
            start = new_start;
            finish = new_finish;
            end_of_storage = start + capacity - 1;
        }
    }
    void pop_back(){//弹出的意义是不在含有该对象
        Allocator a;
        a.destroy(--finish); //finish指向尾后位置，自减后销毁了对象，不存在了
        length -= 1;

    }
    iterator insert(const_iterator position, const T&value);
    T& operator[](size_t n){return *(start + n); } //如果index out of bound or Vector为空 ,让用户自己去处理
    const T& operator[](size_t n)const {  return *(start + n); }
    T& front(){ return *start; }
    const T&front()const{ return *start; }
    T& back(){ return *(finish-1); }
    const T&back()const{ return *(finish - 1); }
    size_t size(){ return length; }
    size_t volume(){ return capacity; }
    iterator begin(){ return start; }
    const_iterator cbegin()const { return start; }
    iterator end(){ return finish; }
    const_iterator cend(){ return finish; }
    Vector& operator=(const Vector&rhs){
        if (this->start ==rhs.start) return *this; //两个相等，两个相同
        //释放掉原有的内存空间，allocator分配的空间如果不deallocate,会造成内存泄漏
        auto old_start = this->start;
        auto old_finish = this->finish;
        size_t old_capacity = this->capacity;
        capacity = rhs.capacity;
        length = rhs.length;
        Allocator a;
        start = a.allocate(capacity);
        end_of_storage = start + capacity - 1;
        finish = start + length;

        for (T* p = start, *q = rhs.start; p != finish; p++, q++){
            a.construct(p, *q);
        }
        Allocator b;//是需要重新创建b，还是用前面的a就可以完成下面的动作
        T* p = old_start;
        while (p!=old_finish)
        {
            b.destroy(p++);
        }
        b.deallocate(old_start, old_capacity);
        return *this;
        
    };
    ~Vector(){
        Allocator a;
        T* p = start;
        while (p!= finish)
        {
            a.destroy(p++);
        }
        a.deallocate(start, capacity);
        start = finish = end_of_storage = NULL; //是否多余语句
        cout << " dectr completed";
    }
    
};
template<typename T> 
class demo{
public:
    demo():d(){}
    T size();
private:
    T d;
};
class foo{
public:
    foo() :a(5), s("dka"){}
private:
    int a; string s;

};

int main()
{
    Vector<string> v1;
    cout << v1.volume() << " " << v1.size() << "\n";
    Vector<string> v2(10);//10个空串，调用了string的default ctr
    cout << v2.size() << " " << v2.volume() << endl;
    cout << "the first item of v2: " << v2[0] << " or " << v2.front() << endl;
    //Vector<string> v3(10, 'c'); no instance of parameters (int,char)
    Vector<string> v4(10, "c");
    Vector<string> v5(v4);
    cout << v5.back() << " " << v5.size() << v5.volume() << endl;
    v5 = v1;
    for (auto it = v5.begin(); it!= v5.end();it++)
    {
        cout << *it;
    }
    /*cout << v5[0] << endl;*/ 

    Vector<string> v6(v1); //用空vector初始化另一个vector ;这两个vector都应该表现正常
    for (auto it = v6.cbegin(); it != v6.cend();it++)
    {    
        cout << *it << endl;
    }
    v1 = v4;//v1原本为空，用含10个元素的v4赋值，并用push_back添加尾元素
    for (auto x : v1) cout << x << endl;
    v1.push_back("hdwa");
    cout << v1.size() << v1[10] << endl;
    v1.pop_back();
    cout << v1.back() << endl;
    string s;
    Vector<int> iv(10);
    for (auto y:iv)
    {
        printf("%d", y);
    }
    Vector<string> v7={ "dak", "dj" };
    cout << v7.volume() << " " << v7.size() << v7[0] << " " << v7[1] << endl;


}