Wczytanie z pliku tekstowego macierzy, następnie mnożenie ich i zapisanie wyniku do innego pliku tekstowego.

#include <iostream>
#include<fstream>
using namespace std;
class matrix {
    int * tab = nullptr;
    int wiersze = 0, kolumny = 0;
public:
    friend ostream & operator <<( ostream & s, matrix & m );
   
    matrix( int w, int k )
        : wiersze( w )
         , kolumny( k )
    { //konstruktor
        cout << "jestem konstruktor" << endl;
        int rozmiar = w * k;
        tab = new int[ rozmiar ];
    }
   
    matrix() { } //konstruktor domyślny nic nie robi
    ~matrix() {
        if( tab ) {
            delete[] tab;
            tab = nullptr;
        }
    }
   
   
    int & operator ()( int w, int k ) {
        return tab[( w - 1 ) * kolumny + k - 1 ];
    }
   
    int row() { return wiersze; }
    int column() { return kolumny; }
    matrix & operator =( matrix && wzor ); //operator przenoszenia
    matrix( matrix && wzor ); //konstruktor przenoszący
    matrix( const matrix & wzor ); //konstruktor kopiujący
    matrix operator *( matrix & m ); //operator mnożenia macierzy
    matrix & operator =( const matrix & wzor ); //operator przypisania. Ten nie powinien się odpalić w c++11
};



matrix & matrix::operator =( matrix && wzor )
{
    //operator przenoszenia
    cout << "jestem operator przenoszenia" << endl;
    std::swap( wzor.tab, tab ); //przepisanie tylko wskaźnika na macierz bez kopiowania danych
    std::swap( wiersze, wzor.wiersze ); //przepisanie zmiennych "wiersz" oraz "kolumna"
    std::swap( kolumny, wzor.kolumny );
    return * this;
}
matrix::matrix( matrix && wzor )
{
    //konstruktor przenoszący
    cout << "jestem konstruktor przenoszący" << endl;
    tab = wzor.tab; //przepisanie tylko wskaźnika na macierz bez kopiowania danych
    wiersze = wzor.wiersze; //przepisanie zmiennych "wiersz" oraz "kolumna"
    kolumny = wzor.kolumny;
    wzor.tab = nullptr;
}

matrix::matrix( const matrix & wzor ) {
    cout << "jestem konstruktor kopiujący" << endl;
    wiersze = wzor.wiersze;
    kolumny = wzor.kolumny;
    int rozmiar = wiersze * kolumny;
    tab = new int[ rozmiar ];
    for( int i = 0; i < rozmiar; i++ ) { //kopiowanie bufora
        tab[ i ] = wzor.tab[ i ];
    }
}

matrix & matrix::operator =( const matrix & wzor ) {
    cout << "jestem operator przypisania" << endl;
    wiersze = wzor.wiersze;
    kolumny = wzor.kolumny;
    int rozmiar = wiersze * kolumny;
    if( tab ) delete[] tab; // zwalnianie pamięci ze starej tablicy
   
    tab = new int[ rozmiar ]; // alokacja nowej
    for( int i = 0; i < rozmiar; i++ ) { //kopiowanie bufora
        tab[ i ] = wzor.tab[ i ];
    }
    return * this;
}

matrix matrix::operator *( matrix & m ) {
    if( kolumny != m.wiersze ) throw "nie pomnozysz takich macierzy";
   
    matrix temp( wiersze, m.kolumny ); //obiekt tymczasowy tworzenie
    // dalej mnożenie czyli wypełnianie wyżej stworzonego obiektu tymczasowego
    for( int w = 1; w <= temp.wiersze; w++ ) {
        for( int k = 1; k <= temp.kolumny; k++ ) {
            int element = 0;
            for( int i = 1; i <= kolumny; i++ ) element += operator ()( w, i ) * m( i, k );
           
            temp( w, k ) = element;
        }
    }
    //koniec mnożenia zwracam obiekt tymczasowy
    return temp;
}

ostream & operator <<( ostream & s, matrix & m ) {
    for( int w = 1; w <= m.wiersze; w++ ) {
        for( int k = 1; k <= m.kolumny; k++ ) {
            s << m( w, k ) << " ";
        }
        s << endl;
    }
    return s;
}
int main() {
    matrix m1( 5, 5 ); //macierz 5 na 5
    matrix m2( 5, 4 ); //macierz 5 na 4
   
    //wypełniam jedynkami
    for( int w = 1; w <= m1.row(); w++ ) {
        for( int k = 1; k <= m1.column(); k++ ) {
            m1( w, k ) = 1;
        }
    }
    cout << m1 << endl;
   
    //wypełniam dwójkami
    for( int w = 1; w <= m2.row(); w++ ) {
        for( int k = 1; k <= m2.column(); k++ ) {
            m2( w, k ) = 2;
        }
    }
    cout << m2 << endl;
    matrix m3;
    try {
        m3 = m1 * m2;
    }
    catch( char const * p ) {
        cout << p << endl;
        return 0;
    }
    cout << m3 << endl;
    ofstream plik( "wynik.txt" ); //zapis do pliku
    plik << m3;
    //koniec
    return 0;
}