#pragma once

#include <iostream>
#include <cassert>
namespace wear
{
    template < typename T > class base_matrix
    {
    protected:

        size_t baseSize{ 10 };
        T* container{ new T[baseSize] };
        T* operator*() { return container; }
        T& operator&() { return *container; }

        void resize_container(size_t newSize)
        {
            T* tempcontainer{ new T[baseSize] };
            std::memcpy(tempcontainer, container, baseSize);
            container = T[newSize]; baseSize = newSize ;
            std::memcpy(container, tempcontainer, newSize);
            delete[] tempcontainer;
        }

        virtual ~base_matrix() { delete[] container; }

        size_t size() const { return baseSize; }
    };

    template < typename T > class matrix: protected base_matrix < T >
    {
    public:

        matrix() {}
        matrix(std::initializer_list < T >& list) : data(list) { }

        void push(T content)
        {
            if (data.size() <= size)
            {
                data.resize_container(size + 1);
                data[size] = content;
                ++size;
            }
            else
                data[size] = content;
        }

        T at(size_t idContainer) { return &data[idContainer]; }


    private:
        wear::base_matrix < T > data;
        size_t size{ data.size() };
    };

}