#include <iostream>

const unsigned DefaultBlockSize = 10;


template<typename T>
class my_vector
{
    T* parray;
    unsigned size;
    unsigned length;

    unsigned block;

    unsigned calc_alloc(unsigned req)
    {
        unsigned res = req / block;
        if (req % block)
            ++res;
        res *= block;
        return res;
    }

public:
    //Коструктор по умолчанию. Нет аргументов.
    my_vector() : parray(nullptr), size(0), length(0), block(DefaultBlockSize) { }

    //Конструктор копирования. Аргумент - другой вектор
    my_vector(const my_vector& v) : size(v.size), length(v.length), block(v.block)
    {
        //Выделил столько сколько, сколько использовано в векторе-аргументе
        parray = new T[size];

        //создали копию указателя на начало выделенной памяти
        T* pdest = parray;

        //создали копию указателя на начало его выделенной памяти
        const T* psrc = v.parray;

        //и до тех пор пока не скопировали length элементов - копируем элементы
        while (pdest < parray + length)
            *pdest++ = *psrc++;
    }

    //деструктор - освобождает память (иначе память утечет, останемся юез оперативной памяти)
    ~my_vector() {
        if (size)
            delete[] parray;
    }

    //оператор копирующего присваивания
    const my_vector& operator=(const my_vector& v)
    {
        if (size)
            delete[] parray;

        size = v.size;
        length = v.length;
        block = v.block;

        parray = new T[size];
        T* pdest = parray;
        const T* psrc = v.parray;
        while (pdest < parray + length)
            *pdest++ = *psrc++;

        //возвращаем обновленный наш массив (массив - копию аргумента. При этом память наша и его- разные)
        return *this;
    }

    unsigned get_size()
    {
        return size;
    }
    unsigned get_len()
    {
        return length;
    }

    void change_size(unsigned new_size)
    {
        if (!new_size)
        {
            delete[] parray;
            parray = nullptr;
            size = 0;
            length = 0;
            return;
        }
        new_size = calc_alloc(new_size);
        T* pnewarray = new T[new_size];
        T* pdest = pnewarray;
        const T* psrc = parray;

        if (length > new_size)
            length = new_size;

        while (pdest < pnewarray + length)
            *pdest++ = *psrc++;

        if (size)
            delete[] parray;

        parray = pnewarray;
        size = new_size;
    }
    void change_block(unsigned new_block)
    {
        block = new_block;
    }
    void shrink()
    {
        change_size(length);
    }
    void erase(unsigned l)
    {
        if (l > length)
            l = length;
        length -= l;
        //  for(T* p = parray + length; p < parray + length + l; ++p)
        //   p->~T();
    }
    T& operator[](int index)
    {
        return parray[index];
    }
    T& at(int index)
    {
        if ((unsigned)index < length && index >= 0)
            return parray[index];
        else
        {
            std::out_of_range err("my_vector::at()");
            throw err;
        }
    }
    T& push(T elem, unsigned index);

    T& push_front(T elem)
    {
        return push(elem, 0);
    }
    T& push_back(T elem)
    {
        return push(elem, length);
    }
    T pull(unsigned index)
    {
        T elem = parray[index];

        if (index >= length)
            index = length - 1;

        T* pdest = parray + index;
        T const* psrc = pdest + 1;

        while (psrc < parray + length)
            *pdest++ = *psrc++;

        erase(1);

        return elem;
    }
    T pull_front()
    {
        return pull(0);
    }
    T pull_back()
    {
        return pull(length - 1);
    }
};

template<typename T>
T& my_vector<T>::push(T elem, unsigned index)
{
    if (index > length)
        index = length;
    if (length + 1 > size)
    {
        unsigned new_size = calc_alloc(length + 1);
        T* pnewarray = new T[new_size];
        T* pdest = pnewarray;
        const T* psrc = parray;

        while (pdest < pnewarray + index)
            *pdest++ = *psrc++;

        *pdest++ = elem;

        while (psrc < parray + length)
            *pdest++ = *psrc++;

        delete[] parray;

        parray = pnewarray;
        size = new_size;
    }
    else
    {
        T* pdest = parray + length;
        T const* psrc = pdest - 1;

        while (psrc >= parray + index)
            *pdest-- = *psrc--;

        *pdest = elem;
    }
    ++length;
    return parray[index];
}


int main()
{
    my_vector<int> v;
    v.

    v.push_back(3);
    v.push_back(7);
    v.push_back(7);
    v.push_back(7);
    v.push_back(7);
    v.push_back(7);
    v.push_back(7);

    // my_vector<int>* pa = &v;

    v.push_back(7);

    // my_vector<int> w(v)
    // my_vector<int> w = v;
    my_vector<int> w;
    w = v;

    v.push_back(7);
    v.push_back(7);
    v.push_back(7);
    v.push_back(7);

    v.push(11, 1);

    v.push_front(-1);

    for (unsigned i = 0; i < v.get_len(); i++)
    {
        std::cout << v[i] << ' ';
    }

    v.erase(5);
    for (unsigned i = 0; i < v.get_len(); i++)
    {
        std::cout << v[i] << ' ';
    }

    v.shrink();


    my_vector<std::string> vs;

    vs.push_back("3s");
    vs.push_back("7s");

    vs.push("11s", 1);

    vs.push_front("-1s");

    vs.erase(1);
    vs.pull(1);

    for (unsigned i = 0; i < vs.get_len(); i++)
    {
        std::cout << vs[i] << ' ';
    }

    try
    {
        vs.at(77);
    }
    catch (std::out_of_range& e)
    {
        std::cout << "out of range " << e.what();
    }
}