ООП лаб 12

#include <iostream>
#include <fstream>

using namespace std;

#define inputfilename "input.txt"
#define outputfilename "result.txt"
#define logfilename "log.txt"
#define ERROR_MEMPTY "ERROR: matrix is empty.\n"
#define ERROR_REMPTY "ERROR: result was not calculated.\n"
#define ERROR_USUIT "ERROR: unsuitable matrix.\n"

ofstream ERROR_LOG(logfilename, ios::app);

class matrix {
    int size_line,
        size_column,
        ** p_matrix;
public:
    matrix() {
        size_line = 0;
        size_column = 0;
        p_matrix = NULL;
    }
    matrix(int _size_line, int _size_column) {
        size_line = _size_line;
        size_column = _size_column;
        p_matrix = new int* [size_line];
        for (int i_line = 0; i_line < size_line; i_line++)
            p_matrix[i_line] = new int[size_column]();
    }
    matrix(const matrix& M) {
        if (M.p_matrix == NULL) {
            size_line = 0;
            size_column = 0;
            p_matrix = NULL;
            return;
        }
        size_line = M.size_line;
        size_column = M.size_column;
        p_matrix = new int* [size_line];
        for (int i_line = 0; i_line < size_line; i_line++) {
            p_matrix[i_line] = new int[size_column];
            for (int i_column = 0; i_column < M.size_column; i_column++)
                p_matrix[i_line][i_column] = M.p_matrix[i_line][i_column];
        }
    }
    matrix operator= (const matrix& M) {
        if (M.p_matrix == NULL) {
            size_line = 0;
            size_column = 0;
            p_matrix = NULL;
            return *this;
        }
        size_line = M.size_line;
        size_column = M.size_column;
        p_matrix = new int* [size_line];
        for (int i_line = 0; i_line < size_line; i_line++) {
            p_matrix[i_line] = new int[size_column];
            for (int i_column = 0; i_column < M.size_column; i_column++)
                p_matrix[i_line][i_column] = M.p_matrix[i_line][i_column];
        }
        return *this;
    }
    friend ifstream& operator>> (ifstream&, matrix&);
    friend ofstream& operator<< (ofstream&, matrix&);
    friend matrix operator* (const matrix&, const matrix&);
};

ifstream& operator>> (ifstream& fin, matrix& M) {
    fin >> M.size_line;
    fin >> M.size_column;
    M.p_matrix = new int* [M.size_line];
    for (int i_line = 0; i_line < M.size_line; i_line++) {
        M.p_matrix[i_line] = new int[M.size_column];
        for (int i_column = 0; i_column < M.size_column; i_column++)
            fin >> M.p_matrix[i_line][i_column];
    }

    return fin;
}
ofstream& operator<< (ofstream& fout, matrix& M) {
    if (M.p_matrix == NULL) {
        fout << "in operator<< :\n" << ERROR_MEMPTY;
        ERROR_LOG << "in operator<< :\n" << ERROR_MEMPTY;
        return fout;
    }

    for (int i_line = 0; i_line < M.size_line; i_line++) {
        for (int i_column = 0; i_column < M.size_column; i_column++)
            fout << M.p_matrix[i_line][i_column] << '\t';
        fout << endl;
    }

    return fout;
}

matrix operator* (const matrix& A, const matrix& B) {
    if (A.size_column != B.size_line) {
        matrix ERROR;
        ERROR_LOG << "in operator* :\n" << ERROR_USUIT;
        return ERROR;
    }

    matrix result(A.size_line, B.size_column);
    for (int i_fixed_line = 0; i_fixed_line < A.size_line; i_fixed_line++)
        for (int i_fixed_col = 0; i_fixed_col < B.size_column; i_fixed_col++)
            for (int i_dynamic = 0; i_dynamic < A.size_column; i_dynamic++)
                result.p_matrix[i_fixed_line][i_fixed_col] += A.p_matrix[i_fixed_line][i_dynamic] * B.p_matrix[i_dynamic][i_fixed_col];

    return result;
}

int main() {
    tm* ptr = new tm;
    time_t *lt = new time_t;
    *lt = time(NULL);
    localtime_s(ptr, lt);
    char nowtime[100];
    asctime_s(nowtime, ptr);
    ERROR_LOG << nowtime << endl;

    matrix A, B, C;
    ifstream fin(inputfilename);
    ofstream fout(outputfilename);
    fin >> A;
    fout << A << endl;
    fin >> B;
    fout << B << endl;

    C = A * B;
    fout << "result A * B:\n";
    fout << C << endl;

    fin.close();
    fout.close();
    return 0;
}