Перемножение двух матриц

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <windows.h>
 
int ** create_matrix(int row, int col)
{
    int ** matrix = new int * [row];
    for (int i = 0; i < row; ++i)
        matrix[i] = new int[col];
 
    return matrix;
}
 
void delete_matrix(int ** matrix, int row)
{
    for (int i = 0; i < row; ++i)
        delete [] matrix[i];
    delete [] matrix;
}
 
void fill_matrix_rand(int ** matrix, int row, int col)
{
    Sleep(800);
    srand(time(0));
    for (int i = 0; i < row; ++i)
        for (int j = 0; j < col; ++j)
            matrix[i][j] = 10 + rand()%89;
}
 
int ** multiply_matrices(int ** matrix1, int ** matrix2, int row, int col)
{
    int ** result = create_matrix(row, col);
    for (int i = 0; i < row; ++i)
        for (int j = 0; j < col; ++j)
            result[i][j] = matrix1[i][j] * matrix2[i][j];
    return result;
}
 
void show_matrix(int ** matrix, int row, int col)
{
    for (int i = 0; i < row; ++i)
    {
        for (int j = 0; j < col; ++j)
            std::cout << matrix[i][j] << "\t";
        std::cout << "\n";
    }
    std::cout << "\n";
}
 
int main()
{
    int row;
    std::cout << "Please enter the number of the rows: ";
    std::cin >> row;
 
    int col;
    std::cout << "Please enter the number of the columns: ";
    std::cin >> col;
 
    int ** matrix1 = create_matrix(row, col);
    fill_matrix_rand(matrix1, row, col);
    show_matrix(matrix1, row, col);
    
    int ** matrix2 = create_matrix(row, col);
    fill_matrix_rand(matrix2, row, col);
    show_matrix(matrix2, row, col);
 
    int ** result_matrix = multiply_matrices(matrix1, matrix2, row, col);
    show_matrix(result_matrix, row, col);
 
    delete_matrix(matrix1, row);
    delete_matrix(matrix2, row);
    delete_matrix(result_matrix, row);
 
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
 
// Все методы, связанные с матрицами, начинаю с mx_
 
struct _matrix_type
{
    size_t rows;
    size_t columns;
    int** data;
};
 
// АТЕНСЬОН! Не создавайте матрицу простым инстанцированием
// этой структуры или сами выделяйте под неё память.
// Используйте mx_allocate(), ибо нефиг.
typedef struct _matrix_type mx_t;
 
/**
 * Создаёт новую матрицу заданного размера,
 * выделяя под неё память.
 */
mx_t mx_allocate(size_t rows, size_t columns) {
    // выделяем память под строки
    // берём размер *указателя* на int
    int** matrix = (int**)malloc(sizeof(int*) * rows);
    for (int row = 0; row < rows; row++) {
        // выделяем память внутри строк (ячейки)
        matrix[row] = (int*)malloc(sizeof(int) * columns);
    }
    
    mx_t result = {
        .rows = rows,
        .columns = columns,
        .data = matrix
    };
    
    return result;
}
 
/**
 * Заполняет матрицу случайными числами от 0 до 99.
 */
void mx_random_fill(mx_t mx) {
    for (int r = 0; r < mx.rows; r++) {
        for (int c = 0; c < mx.columns; c++) {
            mx.data[r][c] = rand() % 100;
        }
    }
}
 
/**
 * Выводит матрицу в стандартный поток вывода.
 */
void mx_print(mx_t mx) {
    for (int r = 0; r < mx.rows; r++) {
        for (int c = 0; c < mx.columns; c++) {
            printf("%d ", mx.data[r][c]);
        }
        printf("\n");
    }
}
 
/**
 * Перемножает матрицы за O(n^3).
 */
mx_t mx_multiply(mx_t left, mx_t right) {
    // TODO: Проверка размеров матриц
    mx_t result = mx_allocate(left.rows, right.columns);
    for (int r = 0; r < left.rows; r++) {
        for (int c = 0; c < right.columns; c++) {
            for (int n = 0; n < left.columns; n++) {
                result.data[r][c] += left.data[r][n] * right.data[n][c];
            }
        }
    }
    
    return result;
}
 
/**
 * Освобождает память, отведённую под матрицу.
 */
void mx_free(mx_t matrix) {
    free(matrix.data);
}

 a = new double[L*N];
 b = new double[N*M];
 c = new double[L*M];