#include <iostream>
#include <vector>
#include <cstring>
#include <iostream>
#include <random>
#include <algorithm>


template<typename T>
class Vector
{
public:
    enum
    {
        CAPACITY = 8
    };

    // конструктор
    explicit Vector(std::size_t init_size = 0) : VSize(init_size), VCapacity(init_size + CAPACITY)
    {
        std::cout << "Ctor\n";
        vec = new T[VCapacity];
    }

    // конструктор копирования
    Vector(const Vector &right) : vec(nullptr)
    {
        std::cout << "CCtor\n";
        VSize = right.size();
        VCapacity = right.capacity();

        vec = new T[VCapacity];

        for (int i = 0; i < VSize; ++i)
            vec[i] = right.vec[i];
    }

    // конструктор перемещения
    Vector(Vector &&right) : vec(nullptr)
    {
        std::cout << "CtorMove\n";
        operator=(std::move(right));
    }

    // деструктор
    ~Vector()
    {
        std::cout << "Dtor\n";
        delete[] vec;
    }

    const Vector &operator=(const Vector &right)
    {
        Vector vector(right);
        *this = std::move(vector);
    }

    void resize(std::size_t newSize)
    {
        reserve(newSize * 2 + 1);
        VSize = newSize;
    }

    void reserve(size_t newCapacity)
    {
        if (newCapacity > VCapacity)
        {
            T* tempVec = new T[newCapacity];

            for (int i = 0; i < VSize; i++)
                tempVec[i] = vec[i];

            delete[] vec;
            vec = new T[newCapacity];
            vec = tempVec;
        }


        if (newCapacity < VCapacity)
        {
            for (int i =  VCapacity; i != newCapacity; --i)
                vec[i] = NULL;
        }

        VCapacity = newCapacity;
    }

    T &operator[](int index)
    {
        return vec[index];
    }

    typedef T* viterator;

    viterator begin() const
    {
        return vec;
    }

    viterator end() const
    {
        return vec + VSize;
    }


    const bool empty() const
    {
        return VSize == 0;
    }

    void push_back(T value)
    {
        resize(VSize + 1);
        vec[VSize - 1] = value;
    }

    const size_t size() const
    {
        return VSize;
    }

    const size_t capacity() const
    {
        return VCapacity;
    }
    void pop_back()
    {
        if (!empty())
        {
            vec[VSize - 1] = NULL;
            --VSize;
        }
    }

    const T back()
    {
        if (!empty())
            return vec[VSize - 1];
    }

    const T front()
    {
        if (!empty())
            return vec[0];
    }

    template<typename T1>
    friend std::ostream &operator<<(std::ostream &out, const Vector<T1> &obj);

private:
    std::size_t VSize;
    std::size_t VCapacity;
    T* vec;
};

template<typename T1>
std::ostream &operator<<(std::ostream &out, const Vector<T1> &obj)
{
    // вывод по 10 элементов в одной строке (переменная num).
    int num = 0;
    for (auto &i : obj)
    {
        out << i << " ";
        ++num;
        if (num / 11)
        {
            std::cout << std::endl;
            num = 0;
        }
    }
    std::cout << std::endl;
    return out;
}

int random_generate(int min, int max)
{
    std::random_device rd;     // only used once to initialise (seed) engine
    std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
    std::uniform_int_distribution<int> uni(min,max); // guaranteed unbiased

    return uni(rng);
}

int main()
{

    Vector<int> vec_one(5);

    vec_one[0] = 11;
    vec_one[1] = 17;
    vec_one[2] = 2;
    vec_one[3] = 3;
    vec_one[4] = 14;
    std::cout << vec_one;

    vec_one.push_back(1);
    std::cout << vec_one;

    vec_one.pop_back();

}