Anya6

#include <iostream> //Подключаем библиотеку для потока входных и выходных данных

using namespace std; //используем пространство стандартных имен

// Кратко объявляем класс вектор
class Vector;

// Объявляем класс Matrix
class Matrix
{
  //приватные поля
private:
  int **matrix;    //Матрица
  int n, m;        //размеры матрицы
  int number;      // Номер матрицы
  int multiple = 1;    // Произведение положит. элементов
  //Публичные поля
public:
  // Конструктор
  Matrix(int n, int m, int num);
  // Основной метод для получения количества элемента
  int calculate_multiple();
  // Метод для вывода матрицы
  void output_matrix();

  Matrix(const Matrix &matr);                                        //Конструктор копирования
  Matrix &operator=(const Matrix &right);                            //Переопределение операции присваивания
  friend Matrix operator*(const Matrix &matr1, const Matrix &matr2); //Переопределение оператора умножения
  friend Vector Multiply(const Matrix &matr, const Vector &vector);  //Произведение матрицы на вектор
  Matrix(int n, int m);
  // Деструктор
  ~Matrix();
};

// Описания конструктора
Matrix::Matrix(int n, int m, int num) : n(n), m(m), number(num)
{
  cout << "Enter elements of matrix" << num << " size of " << n << "x" << m << endl;
  // Объявляем матрицу и динамически выделяем память под строки
  matrix = new int *[n];
  for (int i = 0; i < n; i++)
  {
    // Вделяем память под столбцы
    matrix[i] = new int[m];
    for (int j = 0; j < m; j++)
    {
      // Вводим элементы матрицы
      matrix[i][j] = rand() % 8 - 2;
    }
  }
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < m; j++)
    {
      cout << matrix[i][j] << " ";
    }
    cout << endl;
  }
}

// Описание основного метода
int Matrix::calculate_multiple()
{
  for(int i = 0; i < n; i++)
    {
      for(int j = 0; j < m; j++)
      {
        if(i!=j && matrix[i][j] > 0)
        {
          multiple*=matrix[i][j];
        }
      }
    }
    return multiple;
}
//Описание деструктора
Matrix::~Matrix()
{
  for (int i = 0; i < n; i++)
  {
    delete[] matrix[i];
  }
}

//Вывод матрицы
void Matrix::output_matrix()
{
  cout << "Output matrix " << number << endl;
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < m; j++)
    {
      cout << matrix[i][j] << " ";
    }
    cout << endl;
  }
}

//Описание конструктора копирования
Matrix::Matrix(const Matrix &matr)
{
  //Проверка на пустой указатель
  if (matrix != nullptr)
  {
    for (int i = 0; i < n; i++)
    {
      delete[] matrix[i]; //удаляем память
    }
  }
  // Копируем все данные
  this->n = matr.n;
  this->m = matr.m;
  this->number = matr.number;
  this->matrix = new int *[n];
  for (int i = 0; i < n; i++)
  {
    this->matrix[i] = new int[m];
    for (int j = 0; j < m; j++)
    {
      this->matrix[i][j] = matr.matrix[i][j];
    }
  }
}

Matrix::Matrix(int n, int m)
    : n(n), m(m)
{
  matrix = new int *[n];
  for (int i = 0; i < n; i++)
  {
    matrix[i] = new int[m];
    for (int j = 0; j < m; j++)
    {
      matrix[i][j] = 0;
    }
  }
}

//Описание функции переопределения оператора присваивания
Matrix &Matrix::operator=(const Matrix &right)
{
  //Проверка на пустой указатель
  if (matrix != nullptr)
    for (int i = 0; i < n; i++)
    {
      delete[] matrix[i];
    }
  //Копируем все данные
  this->n = right.n;
  this->m = right.m;
  this->matrix = new int *[n];
  for (int i = 0; i < n; i++)
  {
    this->matrix[i] = new int[m];
    for (int j = 0; j < m; j++)
    {
      this->matrix[i][j] = right.matrix[i][j];
    }
  }
  return *this; //Возвращаем ссылку на текущий объект
}

//Описание переопределения оператора умножения
Matrix operator*(const Matrix &matr1, const Matrix &matr2)
{
  //Объявляем новыую матрицу нужных размеров
  Matrix res(matr1.m, matr2.n);
  //Делаем проверку на невозможность умножения
  if (matr1.m != matr2.n)
  {
    cout << "Multiplication is impossible" << endl;
  }
  else
  {
    for (int i = 0; i < matr1.n; i++)
    {
      for (int j = 0; j < matr2.m; j++)
      {
        res.matrix[i][j] = 0;
        for (int k = 0; k < matr1.m; k++)
        {
          res.matrix[i][j] += matr1.matrix[i][k] * matr2.matrix[k][j]; // Перемножаем матрицы по правилу
        }
      }
    }
  }
  return res;
}

class Vector
{
private:
  int len;               //длина вектора
  double *vec = nullptr; //объявляем указатель на вектор и обнуляем его

public:
  Vector(int n);                                                         // Конструктор класса
  Vector(const Vector &vector);                                          //Конструктор копирования
  void input_vec();                                                      //Ввод вектора
  Vector &operator=(const Vector &vector);                               //Переопределение оператора присваивания
  friend Vector operator*(const Vector &vector1, const Vector &vector2); //Переопределение оператора умножения
  friend Vector Multiply(const Matrix &matr, const Vector &vector);      //Умножение матрицы на вектор
  void output_vec();                                                     //Вывод вектора
  ~Vector();                                                             //Деструктор
};

// Конструктор класса Vector
Vector::Vector(int n) : len(n)
{
  vec = new double[n];
  for (int i = 0; i < n; i++)
  {
    vec[i] = 0;
  }
}

//Конструктор копирования
Vector::Vector(const Vector &vector)
{
  //Проверка ну пустой указатель

  if (vec != nullptr)
  {
    delete[] vec;
  }
  len = vector.len;
  vec = new double[len];
  for (int i = 0; i < len; i++)
    vec[i] = vector.vec[i];
}

// Переопределение операции присваивания
Vector &Vector::operator=(const Vector &vector)
{
  if (vec != nullptr)
  {
    delete[] vec;
  }
  len = vector.len;
  vec = new double[len];
  for (int i = 0; i < len; i++)
    vec[i] = vector.vec[i];
  return (*this);
}

void Vector::input_vec()
{
  for (int i = 0; i < len; i++)
  {
    vec[i] = rand() % 50 + 1;
  }
}

Vector operator*(const Vector &vector1, const Vector &vector2)
{
  if (vector1.len < vector2.len)
  {
    for (int i = 0; i < vector1.len; i++)
    {
      vector2.vec[i] *= vector1.vec[i];
    }
    return vector2;
  }
  else
  {
    for (int i = 0; i < vector2.len; i++)
    {
      vector1.vec[i] *= vector2.vec[i];
    }
    return vector1;
  }
}

Vector::~Vector()
{
  delete vec;
}

Vector Multiply(const Matrix &matr, const Vector &vector)
{
  Vector res(matr.n);
  if (matr.m != vector.len)
  {
    cout << "Multiplication is impossible" << endl;
  }
  else
    for (int i = 0; i < matr.n; i++)
    {
      res.vec[i] = 0;
      for (int j = 0; j < matr.m; j++)
        res.vec[i] = res.vec[i] + matr.matrix[i][j] * vector.vec[j];
    }
  return (res);
}

void Vector::output_vec()
{
  for (int i = 0; i < len; i++)
  {
    cout << vec[i] << " ";
  }
  cout << endl;
}

int main()
{
  // Объявление объектов класса Matrix
  Matrix matrix1(5, 4, 1);
  Matrix matrix2(5, 5, 2);
  Matrix matrix3(3, 7, 3);

  // Создание экземпляров класса Vector
  Vector vec1(5);
  vec1.input_vec();

  Vector vec2(7);
  vec2.input_vec();

  //Илюстрация работы конструктора копирования и переопределенного оператора присваивания
  cout << ".......................Copy constructors...................." << endl
       << endl;
  cout << "Counstructor copy for vector:" << endl;
  Vector vec3(vec2);
  cout << "Output of vector 2" << endl;
  vec2.output_vec();
  cout << "Output of vector 3" << endl;
  vec3.output_vec();
  cout << endl << endl;

  cout << "Counstructor copy for matrix:" << endl;
  Matrix matrix4(matrix2);
  cout << "Output of matrix 2" << endl;
  matrix2.output_matrix();
  cout << "Output of matrix 3" << endl;
  matrix4.output_matrix();
  cout << endl << endl;

  cout << ".....................Reload operator........................" << endl << endl;
  cout << "For matrix: " << endl;
  matrix4 = matrix1;
  cout << "Output matrix3" << endl;
  matrix4.output_matrix();
  cout << "Output matrix1" << endl;
  matrix1.output_matrix();
  cout << endl << endl;

  cout << "For vector: " << endl;
  vec3 = vec1;
  cout << "Output vector1" << endl;
  vec1.output_vec();
  cout << "Output vector2" << endl;
  vec3.output_vec();
  cout << endl << endl;

  // Умножение вектора на вектор
  cout << "...............................Multiple of vectors......................" << endl;
  vec3 = vec1 * vec2;
  cout << "Output vector3" << endl;
  vec3.output_vec();
  cout << endl << endl;

  // Умножение матрицы на матрицу
  cout << ".........................Multiple 2 matrix............................." << endl;
  Matrix matrix5(6, 5, 1);
  Matrix matrix6(4, 7, 2);
  matrix4 = matrix5 * matrix6;
  cout << "Output matrix4" << endl;
  matrix4.output_matrix();
  cout << endl << endl;

  // Решение основной задачи
  cout << "The main solve of the task" << endl;
  // Получаем результаты из вызванной функции
  int mult1 = matrix1.calculate_multiple();
  int mult2 = matrix2.calculate_multiple();
  int mult3 = matrix3.calculate_multiple();

  // Подсчет выражения
  int result = mult1 + 2*mult2 - mult3;
  // Выводим результаты
  cout << "Result of expression: " << result << endl;
  return 0;
}