Untitled

//Файл Header.
#include <iostream>
#include <cassert>

using namespace std;

//Клас Vector.
#include "Header.h"

class Vector {
private:
    double* array;
    int size;

public:
    Vector();
    Vector(double*, int);
    explicit Vector(int size);
    void Display();
    void Add(const double& value);
    void Remove();
    int getSize() const;
    double& operator[](const int i);
    Vector operator+(Vector & r);
    Vector operator-(Vector & r);
    Vector & operator=(const Vector & r);
    void Delete();
    ~Vector();
};

//Конструктор за замовчуванням
Vector::Vector() {
    this->array = nullptr;
    this->size = 0;
}
//Конструктор ініціалізації
Vector::Vector(double *arr, int size) {
    this->size = size;
    this->array = new double[size];
    for (int i = 0; i < size; ++i) {
        this->array[i] = arr[i];
    }
}
//Конструктор ініціалізації нулями
Vector::Vector(int size) {
    this->size = size;
    this->array = new double[size]{};
}
//Деструктор
Vector::~Vector() {
    delete[] this->array;
}
//Виводить на екран вектор
void Vector::Display() {
    for (int i = 0; i < this->size; ++i) {
        cout << this->array[i] << ' ';
    }
    cout << endl;
}
//Додавання нового елементу до вектора (в кінець)
void Vector::Add(const double& value) {
    double* temp = this->array; //Тимчасовий масив для зберігання поточного
    this->array = new double[this->size + 1];
    for (int i = 0; i < this->size; ++i) {
        this->array[i] = temp[i];
    }
    this->array[this->size] = value; //Додаємо в кінець поточного масиву потрібне значення
    this->size++;
    delete[] temp;
}
//Видалення елементу з кінця
void Vector::Remove() {
    size--;
    auto* temp = new double[size];;
    for (int i = 0; i < size; i++)
        temp[i] = array[i];
    delete[] array;
    array = temp;
}
//Перевантаження операції []
double &Vector::operator[](const int idx) {
    assert(idx >= 0 && idx < size); //Перевірка на правильність індекса
    return this->array[idx];
}
//Перевантаження операції +
Vector Vector::operator+(Vector &r) {
    assert(this->size == r.size); //Перевірка на розмір векторів (додаємо лише однакові за розміром)
    double* res = new double[size];
    for (int i = 0; i < this->size; ++i) {
        res[i] = this->array[i] + r.array[i];
    }

    return Vector(res, size);
}
//Перевантаження операції +
Vector Vector::operator-(Vector &r) {
    assert(this->size == r.size); //Перевірка на розмір векторів (додаємо лише однакові за розміром)
    double* res = new double[size];
    for (int i = 0; i < this->size; ++i) {
        res[i] = this->array[i] - r.array[i];
    }

    return Vector(res, size);
}
//Перевантаження операції =
Vector & Vector::operator=(const Vector &r) {
    delete[] this->array;

    this->size = r.size;
    this->array = new double[size];
    for (int i = 0; i < size; ++i) {
        this->array[i] = r.array[i];
    }

    return *this;
}
//Видалення вектора
void Vector::Delete() {
    delete[] this->array;

    this->array = nullptr;
    this->size = 0;
}

int Vector::getSize() const {
    return this->size;
}

//Клас Matrix.
#include "Header.h"
#include "Vector.h"

class Matrix {
private:
    Vector* rows;
    int rowsCount;

public:
    Matrix();
    explicit Matrix(Vector* vector, int size);
    void Display();
    Matrix operator*(const Matrix &r);
    Matrix operator*(Vector &r);
    Matrix operator+(const Matrix &r);
    Matrix operator-(const Matrix &r);
    ~Matrix();
};

//Конструктор за замовчуванням
Matrix::Matrix() {
    this->rows = nullptr;
    this->rowsCount = 0;
}
//Конструктор ініціалізації
Matrix::Matrix(Vector *vector, int size) {
    this->rowsCount = size;
    this->rows = new Vector[size];
    for (int i = 0; i < size; ++i) {
        this->rows[i] = vector[i];
    }
}
//Виводить на екран матрицю
void Matrix::Display() {
    for (int i = 0; i < this->rowsCount; ++i) {
        this->rows[i].Display();
    }
}
//Множення матриць
Matrix Matrix::operator*(const Matrix &r) {
    assert(r.rowsCount != 0); //на нульову матрицю не множимо
    for (int i = 0; i < this->rowsCount; ++i) {
        assert(this->rows[i].getSize() == r.rowsCount); //перевірка чи можна множити матрицю (m=n)
    }
    int colCount = r.rows[0].getSize();

    for (int i = 0; i < r.rowsCount; ++i) {
        assert(colCount == r.rows[i].getSize());
    }

    Vector* res = new Vector[colCount];
    auto* sum = new double[colCount];

    for (int i = 0; i < colCount; i++) {
        for (int j = 0; j < this->rowsCount; j++) {
            sum[j] = 0;
            for (int k = 0; k < r.rowsCount; k++) {
                sum[j] += this->rows[i][k] * r.rows[k][j];
            }
        }
       res[i] = Vector(sum, colCount);
    }
    return Matrix(res, this->rowsCount);
}
//Множення матриці на вектор
Matrix Matrix::operator*(Vector &r) {
    assert(r.getSize() != 0); //на нульовий вектор не множимо
    for (int i = 0; i < rowsCount; ++i) {
        assert(this->rows[i].getSize() == r.getSize()); //перевірка чи можна множити вектор (m=n)
    }

    auto* sum = new double;
    Vector* res = new Vector[r.getSize()];
    for (int i = 0; i < r.getSize(); ++i) {
        sum[0] = 0;
        for (int j = 0; j < r.getSize(); ++j) {
            sum[0] += this->rows[i][j] * r[j];
        }
        res[i] = Vector(sum, 1);
    }

    return Matrix(res, r.getSize());
}
//Додавання матриць
Matrix Matrix::operator+(const Matrix &r) {
    assert(this->rowsCount == r.rowsCount); //додаємо лише однакові за розміром матриці
    Vector* res = new Vector[rowsCount];
    for (int i = 0; i < rowsCount; ++i) {
        res[i] = this->rows[i] + r.rows[i];
    }

    return Matrix(res, rowsCount);
}
//
//Віднімання матриць
Matrix Matrix::operator-(const Matrix &r) {
    assert(this->rowsCount == r.rowsCount); //віднімаємо лише однакові за розміром матриці
    Vector* res = new Vector[rowsCount];
    for (int i = 0; i < rowsCount; ++i) {
        res[i] = this->rows[i] - r.rows[i];
    }

    return Matrix(res, rowsCount);
}
//Деструктор
Matrix::~Matrix() {
    delete[] this->rows;
}

//Файл main.cpp.
#include "Headers/Header.h"
#include "Headers/Vector.h"
#include "Headers/Matrix.h"

int main() {
    //Масиви для створення об'єкта класу Vector
    const int size = 2;
    auto* firstArr = new double[size]{3, 7};
    auto* secondArr = new double[size]{6, 2};
    //Створення об'єктів класу Vector
    Vector firstVector(firstArr, size);
    Vector secondVector(secondArr, size);
    //Масиви об'єктів класу Vector для створення об'єкта класу Matrix
    auto* firstVectorArr = new Vector[size]{
        firstVector,
        secondVector
    };
    auto* secondVectorArr = new Vector[size]{
        secondVector,
        firstVector
    };
    //Створення об'єктів класу Matrix
    Matrix firstMatrix(firstVectorArr, size);
    Matrix secondMatrix(secondVectorArr, size);
    //Виведемо матриці на екран
    cout << "First matrix: " << endl;
    firstMatrix.Display();
    cout << "Second matrix: " << endl;
    secondMatrix.Display();
    //Додавання матриць
    cout << "\nFirst matrix + Second matrix: " << endl;
    (firstMatrix + secondMatrix).Display();
    //Віднімання матриць
    cout << "\nFirst matrix - Second matrix: " << endl;
    (firstMatrix - secondMatrix).Display();
    //Множення матриці на вектор
    cout << "\nFirst matrix * first Vector: " << endl;
    (firstMatrix * firstVector).Display();
    //Множення матриці на матрицю
    cout << "\nFirst matrix * Second matrix: " << endl;
    (firstMatrix * secondMatrix).Display();

    cout << "\n\nHave a nice day =)" << endl;
    return 0;
}