Описать класс "Матрица"

#include <iostream.h>
#include <stdlib.h>
 
class matrix
{
     private:
     int rx, ry, matx[][];
     public:
     void matr();
     matrix(int x,int y);
     ~matrix();
     void sum();
     void prel();
};
 
matrix::matrix(int x,int y)
{
    rx=x;
    ry=y;
    for(int i=0;i<rx;i++)
     for(int j=0;j<ry;j++)
       cin>>matx[i][j];
}
 
void matrix::matr()
{
    for(int i=0;i<rx;i++)
    {
     for(int j=0;i<ry;j++)
      std::cout<<matx[i][j]<<" ";
     std::cout<<endl;
    }
}
 
void matrix::sum()
{
     int summ=0;
    for(int i=0;i<rx;i++)
     for(int j=0;j<ry;j++)
      summ+=matx[i][j];
     std::cout<<summ;
}
 
void matrix::prel()
{
    int prell=1;
    for(int i=0;i<rx;i++)
     for(int j=0;j<ry;j++)
      prell*=matx[i][j];
    std::cout<<prell;
}
 
matrix::~matrix(){};
       
main()
{
    matrix c(4,3);
    c.matr();
    c.sum();
    c.prel();
    return 0;
}

std::cout << matrix[i][j];

#include <iostream.h>
#include <stdlib.h>
 
class array
{
    private:
    int razm,arr[];
    public:
     void vivod();
     void vvod();
     ~array();
     array(int x);
};
 
array::array(int x)
{
  razm=x;
};
 
void array::vvod()
{
    for(int i=0;i<razm;i++)
     cin>>arr[i];
};
 
void array::vivod()
{
    for(int i=0;i<razm;i++)
     cout<<arr[i]<<" ";
};
array::~array() {};
 
main()
{
    array b(5);
    b.vvod();
    b.vivod();
}

#include <iostream>
#include <stdexcept>
 
class arr
{
    
public:
    
    arr(size_t cnt = 0);
    arr(const arr& rhs);
    arr(const int* iarr, size_t size);
    ~arr();
    
    const int* iarray() const;
    size_t size() const;
    int& operator [] (size_t index);
    const int& operator [] (size_t index) const;
    
private:
    
    size_t  m_nSize;
    int*    m_pArr;
};
 
arr::arr(size_t cnt)
    : m_nSize(cnt)
{
    m_pArr = new int[m_nSize];
    for(size_t i = 0; i < m_nSize; ++i)
        m_pArr[i] = 0;
}
 
arr::arr(const arr& rhs)
    : m_nSize(rhs.m_nSize)
{
    m_pArr = new int[m_nSize];
    for(size_t i = 0; i < m_nSize; ++i)
        m_pArr[i] = rhs.m_pArr[i];
}
 
arr::arr(const int* iarr, size_t size)
    : m_nSize(size)
{
    m_pArr = new int[m_nSize];
    for(size_t i = 0; i < m_nSize; ++i)
        m_pArr[i] = iarr[i];
}
 
arr::~arr()
{
    delete[] m_pArr;
}
 
const int* arr::iarray() const
{
    return m_pArr;
}
 
size_t arr::size() const
{
    return m_nSize;
}
 
int& arr::operator [] (size_t index)
{
    if(index >= m_nSize)
        throw std::out_of_range("The specified index is out of range");
    return m_pArr[index];
}
 
const int& arr::operator [] (size_t index) const
{
    if(index >= m_nSize)
        throw std::out_of_range("The specified index is out of range");
    return m_pArr[index];
}
 
int main()
{
    int iarray[] = {1, 2, 3, 4};
    arr a1(iarray, 4);
    std::cout << "size = " << a1.size() << std::endl;
    for(size_t i = 0; i < a1.size(); ++i)
        std::cout << i << ". " << a1[i] << std::endl;
    return 0;
}

class matrix
{
//...
private:
size_t m_nSize;
arr*   m_pMatrix;
};