Записать матрицы в файл и вывести на экран

#include <iostream>
#include <locale.h>
#include <fstream>
#include <iomanip>
#include <stdlib.h>
#include <string>
 
int main()
{
    using namespace std;
    int i, p, k, b, j, N, matr[20][20]{};
    ofstream file;
    string getcontent;
    setlocale(LC_ALL, "Russian");
    file.open("clesson.txt");
 
    cout << "Введите количество квадратных матриц ";
    cin >> k;
    cout << "Введите размерность квадратных матриц ";
    cin >> N;
    for (b = 0; b < k; b++)
    {
        cout << "Введите элементы матрицы номер " << b + 1 << endl;
        for (i = 0; i < N; i++)
            for (j = 0; j < N; j++)
                cin >> matr[i][j];
 
        cout << b + 1 << " Матрица номер" << " \n";
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            {
                cout << setw(4) << matr[i][j];
                file << setw(4) << matr[i][j];
            }
            file << endl;
            cout << endl;
        }
        file << endl;
    }
    file.close();
    
    ifstream openfile("clesson.txt");
    if (openfile.is_open())
    {
        while (getline(openfile, getcontent))
        {
            cout << getcontent << endl;
        }
    }
    openfile.close();
}

#include <iostream>
#include <fstream>
using std::size_t;
using elem = int;
using ostream_t = std::basic_ostream<char>;
using istream_t = std::basic_istream<char>;
ostream_t& save(ostream_t& oso, elem** m, size_t n ){
    for(size_t i=0; i<n; ++i){
        for(size_t j=0; j<n; ++j)
            oso << m[i][j] << '\t';
        oso << std::endl;
    }
    return oso;
}
istream_t& load(istream_t& iso, elem** &m, size_t& n){
    iso >> n;
    m = new elem*[n];
    for(size_t i=0; i<n; ++i)
       m[i] = new elem[n];
    if (m){
        for(size_t i=0; i<n; ++i)
            for(size_t j=0; j<n; ++j)
                iso >> m[i][j];
    }
    return iso;
}
int main()
{
    elem*** matrix_storage{nullptr};
    size_t* m_sizes{nullptr};
    size_t  ms_size{};
    {
        std::ifstream input("matrix_db.txt");
        if (input){
            input >> ms_size;
            m_sizes = new size_t[ms_size]{};
            matrix_storage = new elem**[ms_size]{nullptr};
            size_t i{ms_size};
            while(i--){
               load(input, matrix_storage[i], m_sizes[i]);
               std::cout << m_sizes[i] << std::endl;
               save(std::cout, matrix_storage[i], m_sizes[i]);
               std::cout << std::endl;
            }
            input.close();
            
            // 
               // работаем с матрицами ТУТ --->>>
            //
            
            // освобождение памяти
            delete [] m_sizes;
            i = ms_size;
            while(i--){
                for(size_t j=0; j<m_sizes[i]; ++j)
                    delete [] matrix_storage[i][j];
                delete [] matrix_storage[i];
            }
            delete [] matrix_storage;
        }
    }
    return 0;
}

    elem*** matrix_storage{nullptr}; // массив матриц
    size_t* m_sizes{nullptr}; // массив размеров для каждой матрицы
    size_t  ms_size{}; // количество матриц хранимых  в matrix_storage

    delete[] m_sizes;

            delete [] matrix_storage;
            delete [] m_sizes;

#include <iostream>
#include <fstream>
#include <string>
using std::size_t;
using elem = int;
using ostream_t = std::basic_ostream<char>;
using istream_t = std::basic_istream<char>;
elem product(elem** m, size_t n);
std::ifstream& print_file(std::ifstream& file);
ostream_t& save(ostream_t& oso, elem** m, size_t n);
istream_t& load(istream_t& iso, elem** &m, size_t& n);
 
int main()
{
    elem*** matrix_storage{ nullptr };
    size_t* m_sizes{ nullptr };
    size_t  ms_size{};
    size_t* matrix_with_odd_product{};
    size_t  modd_size{};
    {
        {
            std::ifstream input("matrix_db.txt");
            if (input) {
                if (input >> ms_size) {
                    m_sizes = new size_t[ms_size]{};
                    matrix_storage = new elem**[ms_size] {nullptr};
                    size_t i{ ms_size };
                    while (i--)
                        load(input, matrix_storage[i], m_sizes[i]);
                }
        }
            
            if (ms_size) {
                matrix_with_odd_product = new size_t[ms_size]{std::string::npos};
                size_t i{ ms_size };
                while (i--)
                    if (product(matrix_storage[i], m_sizes[i]) % 2 != 0)
                        matrix_with_odd_product[modd_size++] = i;
                {
                    std::ofstream out("odd_matrix_db.txt");
                    if (out.is_open()) {
                        if (modd_size) {
                            out << modd_size << std::endl;
                            for (size_t i = 0; i < modd_size; ++i) {
                                size_t size = m_sizes[matrix_with_odd_product[i]];
                                save(out, matrix_storage[matrix_with_odd_product[i]], size);
                            }
                        }
                    }
                }
                {
                    std::ofstream out("matrix_db.txt");
                    if (out.is_open()) {
                        if (ms_size - modd_size) {
                            out << ms_size - modd_size << std::endl;
                            size_t i = ms_size, odd_i = 0;
                            while(i--){
                                size_t size = m_sizes[i];
                                if (i == matrix_with_odd_product[odd_i])
                                    ++odd_i;
                                else
                                    save(out, matrix_storage[i], size);
                            }
                        }
                    }
                }
            }
            delete[] matrix_with_odd_product;
            
            // освобождение памяти
            size_t i{ ms_size };
            while (i--) {
                for (size_t j = 0; j<m_sizes[i]; ++j)
                    delete[] matrix_storage[i][j];
                delete[] matrix_storage[i];
            }
            delete[] matrix_storage;
            delete[] m_sizes;
            {
                std::ifstream file("matrix_db.txt");
                std::cout << "\"matrix_db.txt\" : " << std::endl;
                if (file.is_open())
                    print_file(file);
 
            }
            {
                std::ifstream file("odd_matrix_db.txt");
                std::cout << "\"odd_matrix_db.txt\" : " << std::endl;
                if (file.is_open())
                    print_file(file);
            }
        }
    }
    return 0;
}
 
elem product(elem** m, size_t n) {
    elem res{ 1 };
    for (size_t i = 0, j = n - 1; i<n; ++i, --j)
        res *= m[i][i] * m[i][j];
    return res;
}
std::ifstream& print_file(std::ifstream& file) {
    std::string line;
    while (std::getline(file, line))
        std::cout << line << std::endl;
    return file;
}
ostream_t& save(ostream_t& oso, elem** m, size_t n) {
    oso << n << std::endl;
    for (size_t i = 0; i<n; ++i) {
        for (size_t j = 0; j<n; ++j)
            oso << m[i][j] << '\t';
        oso << std::endl;
    }
    return oso;
}
istream_t& load(istream_t& iso, elem** &m, size_t& n) {
    iso >> n;
    m = new elem*[n];
    for (size_t i = 0; i<n; ++i)
        m[i] = new elem[n];
    if (m) {
        for (size_t i = 0; i<n; ++i)
            for (size_t j = 0; j<n; ++j)
                iso >> m[i][j];
    }
    return iso;
}