C++实现简单的Vector

最近刷面经看到了一个要实现vector类的 然后就试了下
后面还有一篇实现share_ptr的

实现my_vector类

#include<iostream>
#include <initializer_list>

template<class T>
class my_vector {
public:
    //使用初始化列表的构造函数
    //列表容量就是我们vector的大小(size),容量可以给一个初始值，这里我用的还是列表的大小
    my_vector(const std::initializer_list<T>& r) :size(r.size()),volume(r.size()) {
        ptr = new T[volume];
        T* p = ptr;

        //复制列表元素到我们的vector里面
        for (T it : r) {
            *(p++) = it;
        }
    }
    //无参的构造函数 这里容量给了默认值10 也可以#define一个值放这里
    my_vector() :size(0),volume(10) {
        ptr = new T[volume];
    }

    //含参的构造函数 我猜想容量应该为2^n 所以计算了一下
    my_vector(size_t _size) :size(_size) {
        volume =max((int)pow(2, ceil(log2(size))),10);
        ptr = new T[volume];
    }
    //释放容器
    ~my_vector() {
        delete[] ptr;
        ptr = nullptr;
    }

    //返回起始地址和终止地址
    //实现begin() 和end()后可以用for遍历
    T* begin() {
        return ptr;
    }
    T* end() {
        return ptr + size;
    }

    size_t Size() { return size; }
    size_t Volume() { return volume; }
    
    //重载[]实现下标存取
    //判断数组越界
    T& operator[](int i) {
        
        try {
            if (i >= size || i < 0) {
                throw i;
            }
            return *(ptr + i);

        }
        catch (int e) {
           
        }
    }

    //在push_back的时候判断是否需要扩容
    void push_back(T val) {

        if (size >= volume) {
            std::cout << "扩容!!!\n";
            volume *= 2;
            T* tmp = ptr;
            //先扩容，后拷贝，然后删除
            ptr = new T[volume];
            for (int i = 0; i < size; i++) {
                *(ptr + i) = *(tmp + i);
            }
            delete[] tmp;
            tmp = nullptr;
        }
        //向末尾添加元素并增加size
        
        *(ptr + size) = val;
        size++;
        //std::cout << *(ptr + size - 1) << std:: endl;
    }


private:
    T* ptr;
    size_t size;
    size_t volume;
};

测试my_vecotr

template<typename T>
void printArr(my_vector<T>& arr) {
//因为my_vector实现了begin(),end()
    for (T it : arr) {
        cout << it << " ";
    }
    cout << endl;
}

//简单写了个快排来测试（bushi）
//好吧也是复习的。。。
template<typename T, typename F>
void Quicksort(my_vector<T>& arr, F cmp, int begin = 0, int end = -2) {
    if (end == -2)end = arr.Size() - 1;
    if (begin >= end)return;

    int l = begin, r = end;
    int k = l;

    while (l < r) {
        while (cmp(arr[k], arr[r]) && l < r)r--;
        while (cmp(arr[l], arr[k]) && l < r)l++;
        swap(arr[l], arr[r]);
    }
    swap(arr[l], arr[k]);

    Quicksort(arr, cmp, begin, l - 1);
    Quicksort(arr, cmp, l + 1, end);


}

int main() {
    my_vector<int> arr { 4,2,5,7,10 };
    Quicksort(arr, [](int a, int b) {return a >= b; });
    printArr(arr);
}