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(){
     end_of_storage = NULL;
     length = ;
     capacity = ;
     }
     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 <= ){ p = a.allocate();
         capacity = ;
         }
         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 <= ) end_of_storage = start + ;
         else     end_of_storage = p + static_cast<int>(1.5*n)-;
         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 - ;
         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 == ){ //为空容器时需要申请新空间
             Allocator a;
              start = a.allocate();
             a.construct(start, value);
             finish = start + ;
             end_of_storage = start + ;
             length = ;
             capacity = ;
         }
         else if (length < capacity){
             Allocator a;
             a.construct(finish++, value);
             length += ;
         }
         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, , value);
             //释放掉旧空间
             capacity = static_cast<size_t>(1.5*capacity);
             length += ;

             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 - ;
         }
     }
     void pop_back(){//弹出的意义是不在含有该对象
         Allocator a;
         a.destroy(--finish); //finish指向尾后位置，自减后销毁了对象，不存在了
         length -= ;

     }
     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-); }
     const T&back()const{ return *(finish - ); }
     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 - ;
         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(), s("dka"){}
 private:
     int a; string s;

 };

 int main()
 {
     Vector<string> v1;
     cout << v1.volume() << " " << v1.size() << "\n";
     Vector<string> v2();//10个空串，调用了string的default ctr
     cout << v2.size() << " " << v2.volume() << endl;
     cout << "the first item of v2: " << v2[] << " or " << v2.front() << endl;
     //Vector<string> v3(10, 'c'); no instance of parameters (int,char)
     Vector<string> v4(, "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[] << endl;
     v1.pop_back();
     cout << v1.back() << endl;
     string s;
     Vector<int> iv();
     for (auto y:iv)
     {
         printf("%d", y);
     }
     Vector<string> v7={ "dak", "dj" };
     cout << v7.volume() << " " << v7.size() << v7[] << " " << v7[] << endl;

 }