Разработать класс Tmatrix - C++

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <ctime>
 
class TMatrix
{
   public:
      static const size_t CMaxCol = 10;
      static const size_t CMaxRow = 10;
 
   protected:
      size_t col, row;
      int matrix[CMaxRow][CMaxCol];
 
   public:
      TMatrix();
      TMatrix(size_t, size_t, size_t, size_t);
      // Вообще-то такой конструктор лишний, ибо выделение
      // памяти отсутствует
      TMatrix(const TMatrix& obj);
 
      void Clear();
      void Fill(size_t, size_t);
 
      int GetMaxValue() const;
      int GetMinValue() const;
 
      bool SortCol(size_t);
      bool SortRow(size_t);
 
      bool operator == (const TMatrix&) const;
      TMatrix operator + (const TMatrix&) const;
      TMatrix operator - (const TMatrix&) const;
 
      friend std::ostream& operator << (std::ostream&, const TMatrix&);
};
//----------------------------------------------//
TMatrix::TMatrix(): col(CMaxCol), row(CMaxRow)
{
   Clear();
}
//----------------------------------------------//
TMatrix::TMatrix(size_t theCol, size_t theRow, size_t theMin, size_t theMax)
{
   Clear();
   col = (theCol < CMaxCol) ? theCol : CMaxCol;
   row = (theRow < CMaxRow) ? theRow : CMaxRow;
 
   Fill(theMin, theMax);
}
//----------------------------------------------//
TMatrix::TMatrix(const TMatrix& obj)
{
   *this = obj;
}
//----------------------------------------------//
void TMatrix::Clear()
{
   memset(matrix, 0, sizeof(matrix));
}
//----------------------------------------------//
void TMatrix::Fill(size_t theMin, size_t theMax)
{
   for (size_t i = 0; i < row; ++i)
   {
      for (size_t j = 0; j < col; ++j)
      {
         matrix[i][j] = (rand() % (theMax - theMin)) + theMin;
      }
   }
}
//----------------------------------------------//
int TMatrix::GetMaxValue() const
{
   size_t maxcol = 0, maxrow = 0;
   for (size_t i = 0; i < row; ++i)
   {
      for (size_t j = 0; j < col; ++j)
      {
         if (matrix[maxrow][maxcol] < matrix[i][j])
         {
            maxrow = i;
            maxcol = j;
         }
      }
   }
   return matrix[maxrow][maxcol];
}
//----------------------------------------------//
int TMatrix::GetMinValue() const
{
   size_t mincol = 0, minrow = 0;
   for (size_t i = 0; i < row; ++i)
   {
      for (size_t j = 0; j < col; ++j)
      {
         if (matrix[minrow][mincol] > matrix[i][j])
         {
            minrow = i;
            mincol = j;
         }
      }
   }
   return matrix[minrow][mincol];
}
//----------------------------------------------//
bool TMatrix::SortCol(size_t theCol)
{
   if (theCol >= col)
   {
      return false;
   }
 
   for (size_t i = 0; i < (row - 1); ++i)
   {
      size_t min = i;
      for (size_t j = (i + 1); j < row; ++j)
      {
         if (matrix[min][theCol] > matrix[j][theCol])
         {
            min = j;
         }
      }
      int tmp = matrix[min][theCol];
      matrix[min][theCol] = matrix[i][theCol];
      matrix[i][theCol] = tmp;
   }
 
   return true;
}
//----------------------------------------------//
bool TMatrix::SortRow(size_t theRow)
{
   if (theRow >= row)
   {
      return false;
   }
 
   for (size_t i = 0; i < (col - 1); ++i)
   {
      size_t min = i;
      for (size_t j = (i + 1); j < col; ++j)
      {
         if (matrix[theRow][min] > matrix[theRow][j])
         {
            min = j;
         }
      }
      int tmp = matrix[theRow][min];
      matrix[theRow][min] = matrix[theRow][i];
      matrix[theRow][i] = tmp;
   }
 
   return true;
}
//----------------------------------------------//
bool TMatrix::operator == (const TMatrix& obj) const
{
   bool equals = (col == obj.col) && (row == obj.row);
 
   for (size_t i = 0; equals && (i < row); ++i)
   {
      for (size_t j = 0; equals && (j < col); ++j)
      {
         equals = (matrix[i][j] == obj.matrix[i][j]);
      }
   }
 
   return equals;
}
//----------------------------------------------//
TMatrix TMatrix::operator + (const TMatrix& obj) const
{
   TMatrix result;
 
   if ((col == obj.col) && (row == obj.row))
   {
      result.col = col;
      result.row = row;
 
      for (size_t i = 0; i < row; ++i)
      {
         for (size_t j = 0; j < col; ++j)
         {
            result.matrix[i][j] = matrix[i][j] + obj.matrix[i][j];
         }
      }
   }
 
   return result;
}
//----------------------------------------------//
TMatrix TMatrix::operator - (const TMatrix& obj) const
{
   TMatrix result;
 
   if ((col == obj.col) && (row == obj.row))
   {
      result.col = col;
      result.row = row;
 
      for (size_t i = 0; i < row; ++i)
      {
         for (size_t j = 0; j < col; ++j)
         {
            result.matrix[i][j] = matrix[i][j] - obj.matrix[i][j];
         }
      }
   }
 
   return result;
}
//----------------------------------------------//
std::ostream& operator << (std::ostream& os, const TMatrix& obj)
{
   for (size_t i = 0; i < obj.row; ++i)
   {
      for (size_t j = 0; j < obj.col; ++j)
      {
         os << obj.matrix[i][j] << " ";
      }
      os << std::endl;
   }
   return os;
}
//----------------------------------------------//
 
int main()
{
   srand(time(NULL));
 
   TMatrix matrix(10, 4, 10, 20);
 
   std::cout << matrix << std::endl;
   std::cout << "max: " << matrix.GetMaxValue() << std::endl
             << "min: " << matrix.GetMinValue() << std::endl << std:: endl;
 
   TMatrix newMatrix(matrix);
 
   std::cout << ((matrix == newMatrix) ? "equals" : "not equals")
             << std::endl << std::endl;
 
   matrix.SortCol(1);
   matrix.SortRow(1);
 
   std::cout << matrix << std::endl;
   std::cout << ((matrix == newMatrix) ? "equals" : "not equals")
             << std::endl << std::endl;
 
   std::cout << (matrix + newMatrix) << std::endl;
 
   std::cout << (matrix - newMatrix) << std::endl;
 
   system("pause");
 
   return 0;
}