5.15作业vector

template <typename T>

class Myvector

{

private:

        T * first;

        T * last;

        T * end;

};

要实现的函数： 构造函数 析构函数 拷贝构造 拷贝赋值

at()

empty()

full()

front()

back()

size()

clear()

expand()

 push_back()

pop_back()

#include <iostream>
#include <vector>

using namespace std;

template <typename T>
class Myvector
{

    private:
        T * first;
        T * last;
        T * end;
        
        void expand()
           {
               size_t capacity = end - first;
               size_t size = last - first;
       
               T *newFirst = new T[capacity * 2]();
               for (size_t i = 0; i < size; ++i)
               {
                   newFirst[i] = first[i];
               }
       
               delete []first;
               first = newFirst;
               last = first + size;
               end = first + capacity * 2;
           }
        
    public:
         Myvector()     //无参构造
         {
             first = nullptr;
             last = nullptr;
             end = nullptr; 
         }
         
         Myvector(int n)       //有参构造
         {
             first = new T[n];
             last = first + n;
             end = last;
         }
         
         //拷贝构造
         Myvector(const Myvector &other)
         {
              size_t length=other.size;
              first = new T[length];
              last = first + length;
              end = last;
              
              for(size_t i = 0;i<length;i++)
              {
                  first[i] = other.first[i];
              }
         }
         
         //拷贝赋值
         Myvector & operator=(const Myvector &other)
         {
              size_t length=other.size;
              if(this != &other)
              {
                  delete[] first;
                  
                  first = new T[length];
                  last = first + length;
                  end = last;
                  
                  for(size_t i = 0;i<length;i++)
                  {
                      first[i] = other.first[i];
                  }
             }
              return  *this;
         }
         
         //析构函数
         ~Myvector ()
         {
             delete[] first;
                     
         }
         char &at(int pos);
         T & at (size_t pos)
         {
             if(pos >= size())
             {
                
             }
              return first[pos];
         }
         
         bool empty() const { return first == last; }
         
         bool full() const { return last == end; }
         T & front() { return *first; }
         T & back()  { return *(last - 1); }
        
         size_t size() const { return last - first; }
         
         void clear() { last = first; }
        
         void push_back(const T &val)
            {
                if (full())
                {
                    expand();
                }
                *last++ = val;
            }
         
         void pop_back()
            {
                if(empty())
                {
                    throw out_of_range("pop_back on an empty vector.");
                }
                --last;
            }
         
};