Объектно-ориентированное программирование

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <cassert>
 
class Matrix {
 public:
  Matrix() : rows_(0), cols_(0), data_(NULL) {}
  Matrix(int rows, int cols) : rows_(rows), cols_(cols) {
    data_ = new int*[rows_];
    for (size_t i = 0; i < rows_; ++i)
      data_[i] = new int[cols_];
  }
  Matrix(const Matrix &other) : rows_(0), cols_(0), data_(NULL) {
    CopyFrom(other);
  }
  ~Matrix() {
    Clear();
  }
  void CopyFrom(const Matrix &other) {
    Clear();
    rows_ = other.rows_;
    cols_ = other.cols_;
    data_ = new int*[rows_];
    for (size_t i = 0; i < rows_; ++i) {
      data_[i] = new int[cols_];
      for (size_t j = 0; j < cols_; ++j)
        data_[i][j] = other.data_[i][j];
    }
  }
  void Clear() {
    for (size_t i = 0; i < rows_; ++i) delete [] data_[i];
    delete [] data_;
    data_ = NULL;
    cols_ = rows_ = 0;
  }
  void FillRandom() {
    srand(time(NULL));
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < cols_; ++j)
        data_[i][j] = rand() % 100;
  }
  void FillZero() {
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < cols_; ++j)
        data_[i][j] = 0;
  }
  Matrix Transposition() const {
    Matrix result(rows_, cols_);
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < cols_; ++j)
        result[i][j] = data_[j][i];
    return result;
  }
  Matrix Multiply(const Matrix &other) const {
    assert(cols_ == other.rows_);
    Matrix result(rows_, other.cols_);
    result.FillZero();
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < other.cols_; ++j)
        for (size_t k = 0; k < cols_; ++k)
          result[i][j] += data_[i][k] * other.data_[k][j];
    return result;
  }
  size_t Cols() const { return cols_; }
  size_t Rows() const { return rows_; }
  int At(int i, int j) const {
    return data_[i][j];
  }
  int *operator[](int n) {
    return data_[n];
  }
  Matrix &operator=(const Matrix &other) {
    if (&other == this) return *this;
    CopyFrom(other);
    return *this;
  }
  bool operator==(const Matrix &other) {
    if (cols_ != other.Cols() || rows_ != other.Rows())
      return false;
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < cols_; ++j)
        if (data_[i][j] != other.At(i, j))
          return false;
    return true;
  }
  Matrix operator+(const Matrix &other) {
    assert(cols_ == other.Cols() && rows_ == other.Rows());
    Matrix result(rows_, cols_);
    result.FillZero();
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < cols_; ++j)
        result[i][j] = data_[i][j] + other.data_[i][j];
    return result;
  }
  Matrix operator-(const Matrix &other) {
    assert(cols_ == other.Cols() && rows_ == other.Rows());
    Matrix result(rows_, cols_);
    result.FillZero();
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < cols_; ++j)
        result[i][j] = data_[i][j] - other.data_[i][j];
    return result;
  }
  Matrix operator*(int number) const {
    Matrix result(rows_, cols_);
    result.FillZero();
    for (size_t i = 0; i < rows_; ++i)
      for (size_t j = 0; j < cols_; ++j)
        result[i][j] = data_[i][j] * number;
    return result;
  }
  Matrix operator*(const Matrix &other) {
    return Multiply(other);
  }
  friend std::ostream &operator<<(std::ostream& o, const Matrix &matrix) {
    for (size_t i = 0; i < matrix.rows_; ++i) {
      for (size_t j = 0; j < matrix.cols_; ++j)
        o << " " << matrix.At(i, j);
      o << std::endl;
    }
    return o;
  }
 private:
  size_t rows_;
  size_t cols_;
  int **data_;
};
 
int main(int argc, char *argv[]) {
  Matrix a(3, 5), b(5, 3);
  a.FillRandom();
  b.FillRandom();
  a = a * 2 + a - a;
  Matrix c = a * b;
  std::cout << a << "x" << std::endl << b << "=" << std::endl 
            << c  << std::endl
            << ((c == (a * b)) ? "c == a * b" : "c != a * b") << std::endl;
  return 0;
}