Создать класс для работы с прямоугольной матрицей размером 3х3

#include <iostream>
#include <initializer_list>
#include <stdexcept>
#include <iomanip>
 
template<typename T>
class M3
{
private:
    typedef typename std::initializer_list<std::initializer_list<T>>::const_iterator cListIter;
    typedef typename std::initializer_list<T>::const_iterator cIter;
    T** p;
    static std::size_t const msize;
    void allocate()
    {
        p = new T*[msize];
        std::size_t i, j;
        try
        {
            for(i = 0; i < msize; ++i)
            {
                p[i] = new T[msize];
            }
        }
        catch (std::bad_alloc const&)
        {
            while(i--)
            {
                delete[] p[i];
            }
            delete[] p;
            throw;
        }
        return;
    }
public:
    M3(std::initializer_list<std::initializer_list<T>> l = std::initializer_list<std::initializer_list<T>>({{T(), T(), T()}, {T(), T(), T()}, {T(), T(), T()}}))
    {
        if(msize != l.size())
        {
            throw std::invalid_argument("matrix must be 3 x 3");
        }
        for(auto const& lst : l)
        {
            if(msize != lst.size()) throw std::invalid_argument("matrix must be 3 x 3");
        }
        allocate();
 
        std::size_t i = 0, j;
        for(cListIter it = l.begin(); i < msize; ++i, ++it)
        {
            j = 0;
            for(cIter subIt = it->begin(); j < msize; ++j, ++subIt)
            {
                p[i][j] = *subIt;
            }
        }
        return;
    }
 
    M3(M3 const& m)
    {
        allocate();
        for(std::size_t i = 0; i < msize; ++i)
        {
            for(std::size_t j = 0; j < msize; ++j)
            {
                p[i][j] = m.p[i][j];
            }
        }
        return;
    }
 
    virtual ~M3()
    {
        for(std::size_t i = 0; i < msize; ++i)
        {
            delete[] p[i];
        }
        delete[] p;
        return;
    }
 
    M3& operator=(M3 const& m)
    {
        if(this != &m)
        {
            this->~M3();
            new(this) M3(m);
        }
        return *this;
    }
 
    T* operator[](std::size_t ind)
    {
        if(ind >= msize)
        {
            throw std::out_of_range("ind >= msize");
        }
        else return p[ind];
    }
 
    friend std::istream& operator>>(std::istream& is, M3& m)
    {
        for(std::size_t i = 0; i < msize; ++i)
        {
            for(std::size_t j = 0; j < msize; ++j)
            {
                std::cout << "p[" << i << "][" << j << "] = ";
                is >> m.p[i][j];
            }
        }
        return is;
    }
 
    friend std::ostream& operator<<(std::ostream& os, M3 const& m)
    {
        for(std::size_t i = 0; i < msize; ++i)
        {
            for(std::size_t j = 0; j < msize; ++j)
            {
                std::cout << std::setw(5) << std::left << m.p[i][j];
            }
            std::cout << std::endl;
        }
        return os;
    }
};
 
template<typename T>
std::size_t const M3<T>::msize(3);
 
int main()
{
    M3<int> m({{-19,-5,19},{22,22,22},{3,3,3}}), m1({{5,5,5},{6,6,6},{7,7,7}}), m2;
    std::cin >> m2;
    m2[0][1] = -78;
    std::cout << m2 << std::endl;
    return 0;
}