Basic C++ vector implementation

vector.cpp

#include <cstddef>
#include <iterator>

template <typename T>
class vector {
   private:
    std::size_t size_;
    std::size_t space_;
    T* elem_;

   public:
    vector(): size_{0}, space_{8} {
        elem_ = new T[space_];
    }

    vector(std::initializer_list<T> const& list) : size_{list.size()} {
        space_ = 8;

        while (space_ < size_) {
            space_ *= 2;
        }

        elem_ = new T[space_];

        for (auto it = list.begin(), i = 0; it != list.end(); it++, i++) {
            elem_[i] = *it;
        }
    }

    ~vector() { delete[] elem_; }

    void reserve(std::size_t new_space) {
        if (new_space <= 0) {
            throw std::logic_error("space should be a positive number");
        }

        if (new_space <= space_) {
            return;
        }

        while (space_ < new_space) {
            space_ *= 2;
        }

        T* elem_copy_ = new T[space_];

        for (std::size_t i{}; i < size_; i++) {
            elem_copy_[i] = elem_[i];
        }

        delete[] elem_;

        elem_ = elem_copy_;
    }

    void resize(std::size_t new_size) {
        if (new_size == size_) {
            return;
        }

        reserve(new_size);

        if (new_size < size_) {
            T* elem_copy_ = new T[new_size];

            for (std::size_t i{}; i < new_size; i++) {
                elem_copy_[i] = elem_[i];
            }

            delete[] elem_;

            elem_ = elem_copy_;
        } else {
            T* elem_copy_ = new T[new_size];

            for (std::size_t i{}; i < new_size; i++) {
                elem_copy_[i] = elem_[i];
            }

            for (std::size_t i{}; i < new_size - size_; i++) {
                elem_copy_[size_ + i] = T{};
            }

            delete[] elem_;

            elem_ = elem_copy_;
        }

        size_ = new_size;
    }

    std::size_t max_size() const { return space_; }
    std::size_t size() const { return size_; }

    void push_back(T const& e) {
        reserve(size_ + 1);

        elem_[size_] = e;
        size_++;
    }

    T& operator[](std::size_t n) {
        if (n > size_ - 1) {
            throw std::out_of_range("n is out of range");
        }

        return elem_[n];
    }

    T const& operator[](std::size_t n) const {
        if (n > size_ - 1) {
            throw std::out_of_range("n is out of range");
        }

        return elem_[n];
    }

    T* begin() const { return &elem_[0]; }

    T* end() const { return &elem_[size_]; }
};

You're welcome! <3