简单实现一下vector

vector是C++STL中的内容，不过可以自己简单实现以下。
重点是，将其中的数据，使用指针来存放，这就引出了深浅拷贝的问题，必须是深拷贝。
代码中的重载 = 运算符，考虑的很周到了。
以及，取front、back、[ ] 的返回值都是引用，可以用于更改数据。

#include <bits/stdc++.h>
using namespace std;

class myVector {
    
    
    int* p;
    int cnt;
    public:
        myVector (int _cnt = 0): cnt(_cnt) {
    
     // 默认构造函数  在这里就初始化了 cnt
            if (_cnt == 0) {
    
     // 如果类似于 myVector v; myVector v(0); 走该分支
                p = nullptr; 
            } else {
    
     // 否则就申请分配空间
                p = new int[_cnt];
            }
            // p = (_cnt == 0) ? nullptr : new int[_cnt];
        } 

        ~myVector () {
    
    
            if (p != nullptr) delete []p; // p不为空，释放掉内存
        }

        // 复制构造函数，深拷贝
        myVector (const myVector& temp) {
    
    
            // 复制构造函数在初始化时使用，不用delete []p
            cnt = temp.cnt;
            if (temp.cnt == 0) {
    
     // 先判断实参是否是空数组
                p = nullptr; // 如果实参是空数组，此处一定要让p指向空 否则可能析构时，出错
            } else {
    
    
                p = new int[temp.cnt];
                memcpy(p, temp.p, sizeof(int) * temp.cnt);
            }
        }

        // 重载赋值=运算符
        myVector& operator= (const myVector& temp) {
    
    
            if (p == temp.p) return *this; // 先判断两个对象是否相同

            if (temp.cnt == 0) {
    
     // 如果该对象，是空数组
                if (p != nullptr) delete []p; // 判断赋值号左侧的对象是否不是空数组，如果不是，则释放掉分配的内存
                cnt = 0; 
                p = nullptr;   // 令 p 为空
                return *this;
            }
            if (cnt < temp.cnt) {
    
     // 节省空间
                delete []p;
                p = new int[temp.cnt];
            }
            cnt = temp.cnt;
            memcpy(p, temp.p, sizeof(int) * temp.cnt);
            
            return *this;
        }

        int size() const {
    
    
            return cnt;
        }

        void push_back(int x) {
    
    
            int* tp = new int[cnt + 1];
            if (p != nullptr) {
    
    
                memcpy(tp, p, cnt * sizeof(int));
                delete []p;
            }
            tp[cnt++] = x;
            p = tp;
        }

        void pop_back() {
    
    
            if (cnt <=0 ) printf("error\n");
            cnt--;
        }

        int& front() const {
    
    
            return p[0];
        }

        int& back() const {
    
    
            return p[cnt-1];
        }

        int& operator[] (int id) {
    
     // 重载 [] 运算符，实现v[i]，取第i个元素。注意返回值
            return p[id];
        }
};

int main()
{
    
    
    myVector mv1; // 调用默认的无参构造函数，创建对象

    for (int i = 0; i < 5; i++) {
    
    
        mv1.push_back(i);  // 往里面放数据
    }

    cout << mv1[2] << endl; // 调用重载[]函数
    // 等价于  mv1.operator[](2)
    mv1[2] = 8; // 可以作为左值，修改mv1中的数据
    // 等价于 mv1.operator[](2) = 8

    myVector mv2 = mv1;  // 调用复制构造函数，初始化对象mv2

    myVector mv3;
    mv3 = mv1; // 调用重载赋值=号的重载函数

    cout << mv3.size() << endl;

    for (int i = 0; i < 5; i++) {
    
    
        mv1.pop_back();
    }
    mv3 = mv1;
    cout << mv3.size() << endl;
    
    return 0;
}