Нужно решение по перегрузке операторов

[Yura iva]

это файл "умножение матриц"

#include <iostream>
#include<math.h>
#include <time.h>
using namespace std;
int main() {
    srand(time(0));
double a[100][100], b[100][100], c[100][100];
int i,j,l,n;
double s(0);
cout<<"Matrix size:";
cin>>n;
cout<<endl;
 
 
for(i=0; i<n; i++) {
for(j=0; j<n; j++) {
a[i][j] = rand()% 10;
b[i][j] = rand()% 10;
}
}
 
cout<<"a matrix:"<<endl;
for(i=0; i<n; i++) {
for(j=0; j<n; j++) {
cout<<a[i][j]<<" ";
}
cout<<endl;
}
cout<<"b matrix: "<<endl; 
for(i=0; i<n; i++) {
for(j=0; j<n; j++) {
cout<<b[i][j]<<" ";
}
cout<<endl;
}
 
for(i=0; i<n; i++) {
    for(l=0; l<n; l++) {
    s = 0;
        for(j=0; j<n; j++) {
            s += a[i][j]*b[j][l];
        }
    c[i][l] = s;
    }
}
 
cout<<"rezult:"<<endl;
for(i=0; i<n; i++) {
for(j=0; j<n; j++) {
cout<<c[i][j]<<" ";
}
cout<<endl;
}
 
system("pause");
return 0;
}

это файл "как найти обратную матрицу"

#include <iostream>
#include <ctime>
#include <cmath>
#include <iomanip>
 
using namespace std;
 
 void FreeMem(double **matr, int n);
 void FreeMem2(int **matr, int n);
 void PrintMtx(double **matr, int n);
  void PrintMtx2(int **matr, int n);
 void SetMtx(int **matr, int n);
 void TransponMtx(double **matr, double **tMatr, int n);
void Get_matr(int  **matr, int n, int **temp_matr, int indRow, int indCol);
int Det(int **matr, int n);
 
void main()
{
    srand((unsigned)time(NULL));
    setlocale(0, "");
    int n, det;
    cout << "Введите размер матрицы: ";
    cin >> n;
    int **matr = new int * [n];
    double **obr_matr = new double * [n];
    double **tobr_matr = new double * [n];
    for(int i = 0; i < n; i++){
        matr[i] = new int[n];
        obr_matr[i] = new double[n];
        tobr_matr[i] = new double[n];
    }
    SetMtx(matr, n);
    PrintMtx2(matr, n);
    det = Det(matr, n);
    cout << "Определитель матрицы = " << det << endl;
    if(det){
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                int m = n - 1;
                int **temp_matr = new int * [m];
                for(int k = 0; k < m; k++)
                    temp_matr[k] = new int[m];
                Get_matr(matr, n, temp_matr, i, j);
                obr_matr[i][j] = pow(-1.0, i + j + 2) * Det(temp_matr, m) / det;
                FreeMem2(temp_matr, m);
            }
        }   
    }
    else
        cout << "Т.к. определитель матрицы = 0,\nто матрица вырожденная и обратной не имеет!!!" << endl;
    //Транспонирование матрицы
    TransponMtx(obr_matr, tobr_matr, n);
    //Печать обратной матрицы после транспонирования
    PrintMtx(tobr_matr, n);
    FreeMem(tobr_matr, n);
    FreeMem2(matr, n);
    FreeMem(obr_matr, n);
    system("pause");
}
//Функция транспонирования матрицы
 void TransponMtx(double **matr, double **tMatr, int n){//
    for (int i = 0; i < n; i++) 
        for (int j = 0; j < n; j++)
            tMatr[j][i] = matr[i][j];
}
//Функция освобождения памяти
 void FreeMem(double **matr, int n)
{
    for(int i = 0; i < n; i++)
        delete [] matr[i];
    delete [] matr;
}
 void FreeMem2(int **matr, int n)
{
    for(int i = 0; i < n; i++)
        delete [] matr[i];
    delete [] matr;
}
 
//функция заполнения матрицы
 void SetMtx(int **matr, int n)
{
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            matr[i][j] = rand()%10; 
}
 
//функция печати матрицы
 void PrintMtx(double **matr, int n)
{
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++)
            cout << setprecision(1) << setw(8) << matr[i][j];
        cout << endl; 
    }
}
 void PrintMtx2(int **matr, int n)
{
    for (int i = 0; i < n; i++){
        for (int j = 0; j < n; j++)
            cout << setprecision(1) << setw(8) << matr[i][j];
        cout << endl; 
    }
}
//функция вычеркивания строки и столбца
void Get_matr(int **matr, int n, int **temp_matr, int indRow, int indCol)   
{
    int ki = 0; 
    for (int i = 0; i < n; i++){
        if(i != indRow){
            for (int j = 0, kj = 0; j < n; j++){
                if (j != indCol){
                    temp_matr[ki][kj] = matr[i][j];
                    kj++;
                }
            }
            ki++;       
        }
    }
}
 
//==============================================================================================================
//                              вычисление определителя
//==============================================================================================================
//функция вычисления определителя матрицы
int Det(int **matr, int n)  
{
    int temp = 0;   //временная переменная для хранения определителя
    int k = 1;      //степень
    if(n < 1){
        cout<<"Не верный размер матрицы!!!" << endl;
        return 0;
    }
    else if (n == 1)
        temp = matr[0][0];
    else if (n == 2)
        temp = matr[0][0] * matr[1][1] - matr[1][0] * matr[0][1];
    else{
        for(int i = 0; i < n; i++){
            int m = n - 1; 
            int **temp_matr = new int * [m];
            for(int j = 0; j < m; j++)
                temp_matr[j] = new int [m];
            Get_matr(matr, n, temp_matr, 0, i);
            temp = temp + k * matr[0][i] * Det(temp_matr, m);
            k = -k;
            FreeMem2(temp_matr, m);
        }
    }
    return temp;
}

[Yura iva]

это файл "мой код"

#include <iostream>
#include <Windows.h>
#include <iomanip>
#include <ctime>
 
 
using namespace std;
 
class Matrix_1{
    private:
        int a;
        int **Mart;
        
    public:
        Matrix_1(int i) :a(i) {
        Mart = new  int*[a];
        for (int z = 0; z < a; z++)
            Mart[z] = new int[a];
            for (int i = 0; i < a; i++)
                for (int j = 0; j < a; j++) {
                    Mart[i][j] = rand() % 10;
                }
        }
        
        Matrix_1(){}
 
        Matrix_1 operator + (Matrix_1 &obj){
            Matrix_1 Tmp(*this);
            for (int i = 0; i < obj.a; i++){
                for (int j = 0; j < obj.a; j++){
                    Tmp.Mart[i][j] = obj.Mart[i][j] + Mart[i][j];
                }
            }
            return Tmp;
        }
 
        Matrix_1 operator - (Matrix_1 &obj){
            Matrix_1 Tmp(*this);
            for (int i = 0; i < obj.a; i++){
                for (int j = 0; j < obj.a; j++){
                    Tmp.Mart[i][j] = Mart[i][j] - obj.Mart[i][j];
                }
            }
            return Tmp;
        }
    
/*      Matrix_1 operator * (Matrix_1 &obj){
            int s;
            Matrix_1 Tmp(*this);
            for (int i = 0; i < obj.a; i++){
                for (int l = 0; l < obj.a; l++){
                    s = 0;
                    for (int j = 0; j < obj.a; j++){
                        s += Mart[i][j] * obj.Mart[j][l];               
                    }
                    Tmp.Mart[i][l] = s;
                }
            }
            return Tmp;
        }
 
*/     
 
        Matrix_1 operator -- (){ 
            Matrix_1 Tmp(*this); 
            for (int i = 0; i < a; i++){ 
                for (int j = 0; j < a; j++){ 
                    Tmp.Mart[i][j]--; 
                } 
            } 
            return Tmp; 
        }
 
 
        void print() {
        for (int i = 0; i < a; i++) {
            for (int j = 0; j < a; j++)
                cout << setw(10) << Mart[i][j];
            cout << "\n";
        }
        cout << "\n";
        }
        friend Matrix_1 operator ++ (Matrix_1);
        friend Matrix_1 operator * (Matrix_1, int);
    
};
 
Matrix_1 operator * (Matrix_1 obj, int m){
    for (int i = 0; i < obj.a; i++){
        for (int j = 0; j < obj.a; j++){
            obj.Mart[i][j] = obj.Mart[i][j] * m;                
        }
    }
    return obj;
}
 
Matrix_1 operator ++ (Matrix_1 obj){ 
    Matrix_1 Tmp = obj; 
    for (int i = 0; i < obj.a; i++){ 
        for (int j = 0; j < obj.a; j++){ 
            Tmp.Mart[i][j]++; 
        } 
    } 
    return Tmp; 
}
 
void end(){ // Функцію для перериву програми
    
            cout << "\n \n Для завершення роботи введiть 0; для продовження - будь яку цифру ";
            int m;
            cin >> m;
            if(m==0) {
                cout << "Роботу завершено.";
                exit(0);
        }
}
 
int main(){
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    srand(time(0));
 
    Matrix_1 N;
 
    int p;
    do{
        system("cls");
        
        cout << "================================================================================" << endl;
        cout << "1 - Додавання матриці" << endl;
        cout << "2 - Віднімання матриці" << endl;
        cout << "3 - Множення двох матриць" << endl;
        cout << "4 - Множення матриць на число" << endl;
        cout << "5 - Знаходження оберненої матриці"<< endl;
        cout << "6 - Збільшення всіх елементів на 1"<< endl;
        cout << "7 - Зменшення всіх елементів на 1"<< endl;
        cout << "0 - Завершити роботу програми" << endl;
 
        while(!(cin >> p)){
            cin.clear();
            while(cin.get() != '\n');
        }
        system("cls");
        switch(p){
            case 1:{int n;
                    cout << "Введіть розмір матриці: ";
                    cin >> n;
                    Matrix_1 A(n), B(n); 
                    cout << "Перша матриця:\n";
                    A.print();
                    cout << "Друга матриця:\n";
                    B.print();
                    A + B;
                    cout << "Сума матриць" << endl;
                    A.print();
                    break;}
            case 2:{int n;
                    cout << "Введіть розмір матриці: ";
                    cin >> n;
                    Matrix_1 A(n), B(n); 
                    cout << "Перша матриця:\n";
                    A.print();
                    cout << "Друга матриця:\n";
                    B.print();
                    A - B;
                    cout << "Різниця матриць" << endl;
                    A.print();
                    break;}
            case 3:{int n;
                    cout << "Введіть розмір матриці: ";
                    cin >> n;
                    Matrix_1 A(n), B(n);
                    cout << "Перша матриця:\n";
                    A.print();
                    cout << "Друга матриця:\n";
                    B.print();
                    A * B;
                    cout << "Матриця після множення:\n";
                    A.print();
                    break;}
            case 4:{int n;
                    cout << "Введіть розмір матриці: ";
                    cin >> n;
                    Matrix_1 A(n), B(n); 
                    int m;
                    cout << "Введіть число на яке потрібно помножити" << endl;
                    cin >> m;
                    cout << "Перша матриця:\n";
                    A.print();
                    cout << "Перша матриця після множення:\n";
                    A * m;
                    A.print();
                    cout << "Друга матриця:\n";
                    B.print();
                    cout << "Друга матриця після множення:\n";
                    B * m;
                    B.print();
                    break;}
            case 5:{int n;
                    cout << "Введіть розмір матриці: ";
                    cin >> n;
                    Matrix_1 A(n), B(n); 
                    cout << "Перша матриця:\n";
                    A.print();
                    cout << "Друга матриця:\n";
                    B.print();
                    break;}
            case 6:{int n;
                    cout << "Введіть розмір матриці: ";
                    cin >> n;
                    Matrix_1 A(n), B(n);
                    cout << "Перша матриця:\n";
                    A.print();
                    cout << "\nПерша матриця після збільшення:\n";
                    A++;
                    A.print();
                    cout << "\nДруга матриця:\n";
                    B.print();
                    cout << "\nДруга матриця після збільшення:\n";
                    B++;
                    B.print();
                    break;}
            case 7:{int n;
                    cout << "Введіть розмір матриці: ";
                    cin >> n;
                    Matrix_1 A(n), B(n);
                    cout << "Перша матриця:\n";
                    A.print();
                    cout << "\nПерша матриця після зменшення:\n";
                    A--;
                    A.print();
                    cout << "\nДруга матриця:\n";
                    B.print();          
                    cout << "\nДруга матриця після зменшення:\n";
                    B--;
                    B.print();
                    break;}
            
            case 0:{cout << "Роботу завершено." << endl; 
                    return 0;}
        }
        if(p != 0){
            end();
        }
    } while(p!=0);
 
    system ("pause");
    return 0;
}

[Yura iva]

Привет всем. Очень нужна помощь по лабораторной.
У меня есть класс и нужно организовать перегрузки операторов.
условие лабораторной работы

Ввести класс для работы с матрицей. Реализовать следующие операции:
- Добавление (вычитание) двух матриц (+, -).
- Умножение двух матриц (*).
- Умножение матрицы на число.
- Нахождение обратной матрицы.

нужно 4 операторы:
унарный и бинарный оператор (обычный в классе) (их у меня несколько)
унарный friend (френдовый) и бинарный friend (френдовый) оператор (их только по одному)

я уже организовал:
- Добавление (вычитание) двух матриц (+, -).
- Умножение матрицы на число.
добавил 2 унарные оператора (operator ++ и operator --)

я не могу сделать:
- Нахождение обратной матрицы.
- Умножение двух матриц (*).

в моем коде есть два операторы operator *
одни для умножения матрицы на матрицу, а другой для умножения матрицы на число
тот что для умножения матрицы я закоментировал
так я хотел сделать умножения матрицы на матрицу но у меня не получилось

я нашел код который работает и по которому можно найти чему будет равняться
- Нахождение обратной матрицы.
- Умножение двух матриц (*).
но не знаю как закинуть нашедший код в свой

и еще если кто-то сможет то напишите метод для освобождения памяти из-под матриц

файл который называется "мой код" это моя лабораторная работа, в нее нужно запихнуть остальные два кода так щоб программа правильно работала и выполняла поставленные задачи

я пользуюсь компилятором который называется Microsoft Visual Studio Express 2012 для Windows Desktop

/* если кто знает украинский язык и сможет написать мне объяснение то пишите */

в архиве я забросил все эти коды, вирусов нет (можете спокойно скачивать)
почему такое название архива я не знаю, закидывал под названием код

[min@y™]

ещё 5000 вёдер и золотой ключик у нас в кармане!

44.jpg