Przesuwanie wskaźników w tablicach dwuwymiarowych

#include <iostream>
using namespace std;

class matrix {
    int * tab = nullptr;
    int offsetw = 0, offsetk = 0;
    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 ) {
        int index_w = w + offsetw;
        int index_k = k + offsetk;
        if( index_w >= wiersze ) index_w -= wiersze;
       
        if( index_k >= kolumny ) index_k -= kolumny;
       
        return tab[ index_w * kolumny + index_k ];
    }
   
    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
   
    void setOffset( int ofw, int ofk );
   
};



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


void matrix::setOffset( int offw, int offk ) {
    if( offw > 0 ) offsetw = offw;
    else if( offw < 0 ) offsetw = wiersze + offw;
    else offsetw = 0;
   
    if( offk > 0 ) offsetk = offk;
    else if( offk < 0 ) offsetk = kolumny + offk;
    else offsetk = 0;
   
}

ostream & operator <<( ostream & s, matrix & m ) {
    for( int w = 0; w < m.wiersze; w++ ) {
        for( int k = 0; k < m.kolumny; k++ ) {
            s << m( w, k ) << " ";
        }
        s << endl;
    }
    return s;
}


int main() {
    matrix m1( 4, 4 ); //macierz 4 na 4
   
    //wypełniam
    int liczba = 10;
    for( int w = 0; w < m1.row(); w++ ) {
        for( int k = 0; k < m1.column(); k++ ) {
            m1( w, k ) = liczba++;
        }
    }
    cout << m1 << endl;
    m1.setOffset( 1, 1 ); //góra lewo o jeden
    cout << m1 << endl;
    m1.setOffset( - 1, - 1 ); //dół prawo o jeden
    cout << m1 << endl;
   
    //dalsze testy klasy matrix!!!
    m1.setOffset( 0, 0 );
    m1( 1, 1 ) = 66; //modyfikuje element (1,1)
    cout << m1( 1, 1 ) << endl; //wyświetlam zmodyfikowany element
    m1.setOffset( 1, 1 ); //tranformacja macierzy (góra i lewo o jeden)
    cout << m1( 0, 0 ) << endl; //zmodyfikowany element to teraz pozycja 0 0
}

#include <iostream>
using namespace std;



int main() {
    int matrix[ 5 ][ 5 ];
    int matrixT[ 5 ][ 5 ];
    //wypełniam
    int liczba = 10;
    for( int w = 0; w < 5; w++ ) {
        for( int k = 0; k < 5; k++ ) {
            matrix[ w ][ k ] = liczba;
            matrixT[ w ][ k ] = liczba;
            liczba++;
        }
    }
   
    int offw = 1, offk = 1; // Tu wybierz o ile i w którą stronę dokonać transformaci
   
   
    //skopiowana funkcja set offset :P nie chciało mi się wymyślać innej metody
    int offsetw, offsetk;
    if( offw > 0 ) offsetw = offw;
    else if( offw < 0 ) offsetw = 5 + offw;
    else offsetw = 0;
   
    if( offk > 0 ) offsetk = offk;
    else if( offk < 0 ) offsetk = 5 + offk;
    else offsetk = 0;
   
   
    // prawie skopiowany operator dostępu do elementu transformacja
    for( int w = 0; w < 5; w++ ) {
        for( int k = 0; k < 5; k++ ) {
            int index_w = w + offsetw;
            int index_k = k + offsetk;
            if( index_w >= 5 ) index_w -= 5;
           
            if( index_k >= 5 ) index_k -= 5;
           
            matrixT[ w ][ k ] = matrix[ index_w ][ index_k ];
        }
    }
   
    //wyświetlenie po transformacji
    for( int w = 0; w < 5; w++ ) {
        for( int k = 0; k < 5; k++ ) {
            cout << matrixT[ w ][ k ] << " ";
        }
        cout << endl;
    }
   
}