C++&QT day7

仿照vector手动实现自己的myVector，最主要实现二倍扩容功能

#include 

using namespace std;

template
class my_vector
{

    int size;//可存储的容量大小
    int num;//当前存储的元素个数
    T* data;//存储数据的空间地址

public:
    //无参构造函数
    my_vector();
    //有参构造函数
    my_vector(int n, const T m);
    //析构函数
    ~my_vector();
    //拷贝构造
    my_vector(const my_vector &other);
    //返回当前的容器大小
    int get_capacity();
    //获取容器中的元素个数
    int get_size();
    //判空函数
    bool empty();
    //添加函数
    void push_back(const T &val);
    //向容器中赋值
    void assign(int n,const T &val);
    //访问容器中的元素
    T& at(int loc);
    //清空容器中的元素
    void clear();
    //删除最后一个元素
    void pop_back();
    //返回起始位置的引用
    T& front();
    //返回最后一个位置的引用
    T& back();
    //返回第一个位置的迭代器
    T* begin();
    //返回末尾下一个位置的迭代器
    T* end();
    //任意插入
    T* insert(T* p, const T& n);
    //遍历
    void show();
};
int main()
{

   my_vector s1;
   s1.assign(7,1);
   cout<<"最大容量"<
my_vector::my_vector()
{
    size=6;
    num=0;
    data = new T[6];
}

//有参构造
template
my_vector::my_vector(int n, const T m)
{
    size = n;
    num = n;
    data = new T[n];
    for(int i=0;i
my_vector::~my_vector()
{
    delete []data;
}

//拷贝构造
template
my_vector::my_vector(const my_vector &other)
{
    size = other.size;
    num  = other.num;
    data = new T[size];

    for(int i=0;i
int my_vector::get_capacity()
{
    return size;
}

template
int my_vector::get_size()
{
    return num;
}

//判空函数
template
bool my_vector::empty()
{
    if(0 == num)
    {
        return true;
    }
    else
        return false;
}

//添加函数
template
void my_vector::push_back(const T &val)
{
    if(num
void my_vector::assign(int n, const T &val)
{
    //判断赋值的个数是否超过最大容量
    if(n>size)
    {

        delete [] data;
        data = nullptr;
        data = new  T [n];
        size = n;
        num = n;
        //赋值
        for(int i=0;i
T& my_vector::at(int loc)
{
    if(loc > num || loc < 0)
    {
        throw T(1);//越界异常
    }
    else
    {
        return data[loc-1];
    }
}

//清空所有元素
template
void my_vector::clear()
{
    while (!empty())
    {
        pop_back();
    }

}

//删除末尾元素
template
void my_vector::pop_back()
{
    if(!empty())
    {
        data[num-1] = 0;
         num--;
    }
    else
        return ;
}

//返回第一个位置的引用
template
T &my_vector::front()
{
    return data[0];
}

//返回最后一个位置的引用
template
T &my_vector::back()
{
    return data[num-1];
}

//返回第一个位置的迭代器
template
T *my_vector::begin()
{
    return &data[0];
}

//返回末尾下一个位置的迭代器
template
T *my_vector::end()
{
    return &data[num];
}

//任意插入
template
T *my_vector::insert(T *p, const T &n)
{
    int j = 0;
      while(&data[0]+j != p) //寻找输入的是第几个数据的地址
      {
          j++;
      }
      if(num == size) //判断当前是否已满
      {
          int i = 0;
          T* data_new = new T[size*2];  //二倍扩容
          size = size * 2;
          while(i < num)       //将旧区的数据内容赋给新区
          {
              data_new[i] = data[i];
              i++;
          }
          delete []data;          //释放旧区
          data = data_new;        //指向新区
          data_new = nullptr;     //新指针置空
          //将指定位置之后的数据全都后移一位
          for(int k = num,i = j;i < num;i++,k--)
          {
                  data[k] = data[k-1];
          }
          data[j] = n;     //插入元素
          num++;               //存储数量加1
          return &data[j];
      }
      else if(num < size)
      {
          //将指定位置之后的数据全都后移一位
          for(int k = num,i = j;i < num;i++,k--)
          {
                  data[k] = data[k-1];
          }
          data[j] = n;     //插入元素
          num++;               //存储数量加1
          return &data[j];
      }
}

//遍历
template
void my_vector::show()
{
    int i = 0;
    for(;i < num;i++)
    {
        cout << data[i] << "\t";
    }
       cout << endl;
}

思维导图：