c++写一个vector

以下是一个简单的C++实现的vector类的示例：

#include <iostream>

namespace yyk {
    template<typename T>
    class vector {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;

        vector() : _start(nullptr), _finish(nullptr), _endofstorage(nullptr) {}

        ~vector() {
            delete[] _start;
        }

        void push_back(const T& value) {
            if (_finish == _endofstorage) {
                size_t oldSize = size();
                size_t newSize = oldSize == 0 ? 1 : oldSize * 2;
                reserve(newSize);
            }
            *_finish = value;
            ++_finish;
        }

        void pop_back() {
            if (_finish != _start) {
                --_finish;
            }
        }

        void resize(size_t newSize) {
            if (newSize < size()) {
                _finish = _start + newSize;
            } else if (newSize > size()) {
                reserve(newSize);
                for (size_t i = size(); i < newSize; ++i) {
                    _start[i] = T();
                }
                _finish = _start + newSize;
            }
        }

        T& front() {
            return *_start;
        }

        const T& front() const {
            return *_start;
        }

        T& back() {
            return *(_finish - 1);
        }

        const T& back() const {
            return *(_finish - 1);
        }

        size_t size() const {
            return _finish - _start;
        }

        void reserve(size_t newCapacity) {
            if (newCapacity > capacity()) {
                size_t oldSize = size();
                T* newStart = new T[newCapacity];
                for (size_t i = 0; i < oldSize; ++i) {
                    newStart[i] = _start[i];
                }
                delete[] _start;
                _start = newStart;
                _finish = _start + oldSize;                _endofstorage = _start + newCapacity;
            }
        }

        T& operator[](size_t index) {
            return _start[index];
        }

        const T& operator[](size_t index) const {
            return _start[index];
        }

        iterator begin() {
            return _start;
        }

        const_iterator begin() const {
            return _start;
        }

        iterator end() {
            return _finish;
        }

        const_iterator end() const {
            return _finish;
        }

    private:
        iterator _start;
        iterator _finish;
        iterator _endofstorage;
    };
}

int main() {
    yyk::vector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);

    std::cout << "Vector size: " << vec.size() << std::endl;
    std::cout << "Vector elements: ";
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}