operator=() przenoszący c++11

#include <iostream>

using namespace std;
class matrix {
    int * tab = NULL;
    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 = NULL;
        }
    }
   
   
    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( 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;
    tab = wzor.tab; //przepisanie tylko wskaźnika na macierz bez kopiowania danych
    wiersze = wzor.wiersze; //przepisanie zmiennych "wiersz" oraz "kolumna"
    kolumny = wzor.kolumny;
    //niszczenie obiektu wzór
    wzor.tab = NULL; //wyzerowanie wskaźnika obiektu wzór
    wzor.wiersze = 0; //wyzerowanie zmiennych w obiekcie wzór
    wzor.kolumny = 0;
    return * this;
}

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 ];
    }
}

matrix matrix::operator *( matrix & m ) {
    if( kolumny == m.wiersze ) { //tylko wtedy mnożenie ma sens
        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;
    } // ponieważ tylko macierze, w których liczba kolumn macierzy "A" jest równa liczbie wierszy macierzy "B" da się pomnożyć
    cout << "nie da sie pomnorzyc" << endl;
    //funkcja nic nie zwraca w przypadku błędnych danych wejściowych
}

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;
    m3 = m1 * m2;
    cout << m3 << endl;
}