#pragma once

#include <cstdlib>
#include <algorithm>

using namespace std;


template <typename T>
class SimpleVector {
public:
    SimpleVector(): _data(nullptr), _end(nullptr), _size(0), _capacity(0){};

    explicit SimpleVector(size_t size) {
        _data = new T[size];
        _end = _data + size;
        _capacity = size;
        _size = size;
    };

    ~SimpleVector() {
        delete []_data;
    };

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

    T* begin() {return _data;};
    T* end() {return _end;};
    const T* begin() const { return _data;}
    const T* end() const { return _end;}

    size_t Size() const {return _size;};

    size_t Capacity() const {return _capacity;};

    void PushBack(const T& value) {
        if (_capacity == 0) {
            _data = new T[1];
            _end = _data + 1;
            _capacity = 1;
            _size = 1;
            *_data = value;
        } else {
            if (Size() == Capacity()) {
                T* new_data = new T[Capacity()];

                copy(_data, _end, new_data);

                delete []_data;
                T* _data = new_data;
                _capacity *= 2;
            }
            _data[_size] = value;
            _size++;
            _end = _data + _size;
        }
    };

private:
    T* _data;
    T* _end;
    size_t _size;
    size_t _capacity;
};