Создание матричной алгебры, что можно улучшить в коде? - C++

#include <cstdlib>
#include <iostream>
 
using namespace std;
 
void halt(int ErrNo) {
  cout << "Ошибка - недопустимая операция.\n";
  exit(ErrNo);
}
 
class Array {
  int **p;
public:
  unsigned char HSize, VSize;
  Array(unsigned char, unsigned char);
  Array(const Array&);
  int* operator[](unsigned char) const;
  Array& operator=(const Array&);
  Array& operator=(int*);
  Array& operator+=(const Array&);
  Array operator+(Array) const;
  Array operator-() const;
  Array operator-(Array) const;
  Array operator*(const Array&) const;
  Array operator*(int) const;
  friend Array operator*(int, Array);
  ~Array();
};
 
Array::Array(unsigned char n, unsigned char m) {
  VSize = n;
  HSize = m;
  p = new int*[VSize];
  for (int i = 0; i < VSize; i++)
    p[i] = new int[HSize];
}
 
Array::Array(const Array& Data) {
  HSize = Data.HSize;
  VSize = Data.VSize;
  p = new int*[VSize];
  for (int i = 0; i < Data.VSize; i++) {
    p[i] = new int[Data.HSize];
    for (int j = 0; j < Data.HSize; j++)
      p[i][j] = Data.p[i][j];
  }
}
 
Array::~Array() {
  for (int i = 0; i < VSize; i++)
    delete [](p[i]);
  delete []p;
}
 
int* Array::operator[](unsigned char i) const {
  if (i >= VSize)
    halt(2);
  return p[i];
}
 
Array& Array::operator=(int* InitData) {
  for (int i = 0; i < VSize; i++)
    for (int j = 0; j < HSize; j++)
      p[i][j] = InitData[i*HSize + j];
  return *this;
}
 
Array& Array::operator=(const Array& Data) {
  if (VSize == Data.VSize && HSize == Data.HSize)
    for (int i = 0; i < VSize; i++)
      for (int j = 0; j < HSize; j++)
        p[i][j] = Data.p[i][j];
  else
    halt(1);
  return *this;
}
 
Array Array::operator-() const {
  Array T(*this);
  for (int i = 0; i < VSize; i++)
    for (int j=0; j < HSize; j++)
      T.p[i][j] = -p[i][j];
  return T;
}
 
Array& Array::operator+=(const Array& Data) {
  if (VSize == Data.VSize && HSize == Data.HSize)
    for (int i = 0; i < VSize; i++)
      for (int j = 0; j < HSize; j++)
        p[i][j] += Data.p[i][j];
  else
    halt(1);
  return *this;
}
 
Array Array::operator+(Array Data) const {
  if (VSize == Data.VSize && HSize == Data.HSize)
    for (int i = 0; i < VSize; i++)
      for (int j = 0; j < HSize; j++)
        Data.p[i][j] += p[i][j];
  else
    halt(1);
  return Data;
}
 
Array Array::operator-(Array Data) const {
  if (VSize == Data.VSize && HSize == Data.HSize)
    for (int i = 0; i < VSize; i++)
      for (int j = 0; j < HSize; j++)
        Data.p[i][j] = p[i][j] - Data.p[i][j];
  return Data;
}
 
Array Array::operator*(const Array& Data) const {
  Array T(VSize, Data.HSize);
  if (HSize == Data.VSize)
    for (int i = 0; i < T.VSize; i++)
      for (int j = 0; j < T.HSize; j++) {
        T.p[i][j] = 0;
        for (int k = 0; k < HSize; k++)
          T.p[i][j] += p[i][k]*Data.p[k][j];
      }
  else
    halt(1);
  return T;
}
 
Array Array::operator*(int k) const {
  Array T(VSize,HSize);
  for (int i = 0; i < VSize; i++)
    for (int j = 0; j < HSize; j++)
      T.p[i][j] = k*p[i][j];
  return T;
}
 
Array operator*(int k, Array Data) {
  for (int i = 0; i < Data.VSize; i++)
    for (int j = 0; j < Data.HSize; j++)
      Data.p[i][j] *= k;
  return Data;
}
 
ostream& operator<<(ostream& s, const Array& Data) {
  s << endl;
  for (int i = 0; i < Data.VSize; i++) {
    for (int j = 0; j < Data.HSize; j++)
      s << '\t' << Data[i][j];
      s << endl;
  }
  s << endl;
  return s;
}
 
int main() {
  Array A(3,3), B(3,3), C(3,2), D(3,3), E(3,3), G(2,3);
  {
    int data[] = {0,1,2,3,4,3,2,1,0};
    B = A = data;
    C = data + 2;
    G = data + 3;
  }
  Array F(A);
  for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++)
      E[i][j] = i == j;
  B += E;
  D = F - E;
  C[2][1] = -5;
  D = -(A*A - 4*B*C*G + E*12)*D;
  cout << "A = F =" << A << "B = " << B << "C = " << C << "G =" << G << "D = -(A*A - 4*B*C*G + E*12)*D = " << D;
  return 0;
} // D = -(A*A - 4*B*C*G + E*12)*D =
// 579 600 435
// 1836 2346 2052
// 563 760 707

// унарный плюс
Array Array::operator+() const {
    Array T(*this);
  for (int i = 0; i < VSize; i++)
    for (int j=0; j < HSize; j++)
      T.p[i][j] = +p[i][j];
  return T;
}
 
// равно
bool Array::operator==(const Array& Data) const {
  for (int i = 0; i < VSize; i++)
    for (int j=0; j < HSize; j++)
      if (Data.p[i][j] != p[i][j])
    return false;
  return true;
}
 
// не равно
bool Array::operator!=(const Array& Data) const {
  for (int i = 0; i < VSize; i++)
    for (int j=0; j < HSize; j++)
      if (Data.p[i][j] != p[i][j])
    return true;
  return false;
}

class Array {
  int **p;
  unsigned char HSize, VSize;
public:
  unsigned char GetHSize() const;
  unsigned char GetVSize() const;
  Array(unsigned char, unsigned char);
  Array(const Array&);
  int* operator[](unsigned char) const;
  Array& operator=(const Array&);
  Array& operator=(int*);
  Array& operator+=(const Array&);
  Array operator+(Array) const;
  Array operator-() const;
  Array operator+() const;
  Array operator-(Array) const;
  Array operator*(const Array&) const;
  Array operator*(int) const;
  bool operator==(const Array&) const;
  bool operator!=(const Array&) const;
  friend Array operator*(int, Array);
  ~Array();
};
 
unsigned char Array::GetHSize() const {
  return HSize;
}
 
unsigned char Array::GetVSize() const {
  return VSize;
}