template<typename T>
class Vector {
public:
    Vector() {
        cap = alloc;
        vector = (T*)malloc(sizeof(T) * alloc);
        elem_num = 0;
    };

    void push_back(const T &data);
    void pop_back();

    [[nodiscard]] bool empty() const;
    [[nodiscard]] size_t size() const;
    [[nodiscard]] size_t capacity() const;
    T &operator[](size_t pos);

    ~Vector();
private:
    T *vector = nullptr;
    size_t cap;
    size_t elem_num;
    const int alloc = 20;
};

template<typename T>
Vector<T>::~Vector() {
    free(vector);
}

template<typename T>
void Vector<T>::push_back(const T &data) {
    if (elem_num < cap) {
        *(vector + elem_num) = data;
        elem_num++;
    } else {
        vector = (T*)realloc(vector, sizeof(T) * cap * 2);
        cap *= 2;

        if (vector) {
            *(vector + elem_num) = data;
            elem_num++;
        }
    }
}

template<typename T>
void Vector<T>::pop_back() {
    if (empty())
        return;
    elem_num--;
}

template<typename T>
T &Vector<T>::operator[](size_t pos) {
    if (pos >= 0 &&  pos <= elems)
        return *(this->arr + pos);
    throw std::out_of_range("Out of bounds element access");
}

template<typename T>
size_t Vector<T>::capacity() const {
    return cap;
}

template<typename T>
bool Vector<T>::empty() const {
    return elem_num == 0;
}

template<typename T>
size_t Vector<T>::size() const {
    return elem_num;
}