Поворот неквадратной матрицы на 90° по часовой стрелке

#include <iostream>
#include <iomanip>
 
///----------------------------------------------------------------------------|
/// Макросы для удобства.
///----------------------------------------------------------------------------:
#define SHOWVAL(v) std::cout << #v << " \t= "<< v << "\n"
#define FORi(n) for(int i = 0; i < n; ++i)
#define FORj(n) for(int j = 0; j < n; ++j)
#define PAUSE   std::cin.get()
 
///----------------------------------------------------------------------------|
/// Двумерный динамический массив инкапсулированный в структуре.
///----------------------------------------------------------------------------:
template<class T>
class carr
{
public:
    carr(int _r, int _c) : arr(NULL), row(_r), column(_c)
    {   arr = create_arr(row, column);
    }
    
   ~carr()
    {   delete_arr(arr);
    }
    
    //------------------------------------------------------resize(int r, int c)
    void resize(int _r, int _c)
    {   row    = _r;
        column = _c;
        if(arr != NULL) 
        {   delete_arr   (arr);
            create_arr(row, column);
        }
        
    }
    
    //-----------------------------------------------------------init_one(T val)
    void init_one(T _val)
    {   FORi(row)
            FORj(column)
                arr[i][j] = _val;
    }
    
    //--------------------------------------------------set(int r, int c, T val)
    void set(int _r, int _c, T _val)
    {   arr[_r][_c] = _val;
        *((T*)(arr + _r*column + _c)) = _val;
    }
    
    //---------------------------------------------------------get(int r, int c)
    T get(int _r, int _c)
    {   return arr[_r][_c];
        //return *((T*)(arr + _r*column + _c));
    }
 
    int row_()
    {   return row;
    }
    int column_()
    {   return column;
    }
    
    //-----------------------------------------------------------Вывод на экран:
    void show()
    {   //std::cout << "\n";
        SHOWVAL(row);
        SHOWVAL(column);
        FORi(row)
        {   FORj(column)
            {   std::cout << std::setw(5) 
                          << std::setprecision(4) 
                          << std::setfill(' ') << arr[i][j] << " \t";
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
 
 
    //--------------------------------------------Вращение по часовой на 90гр..:
    void rot()
    {   T** temp = NULL;
        temp = create_arr(column, row);
        FORi(column)
        {   FORj(row)
            {   temp[i][j] = arr[row-j-1][i];
            }
        }
 
        delete_arr(arr);
        arr = temp;
        std::swap(row, column);
 
    }
 
    T* operator [](const int i)const {return arr[i];}
    
private:
    T** arr;
    
    int row, column;
    
    //--------------------------------------------------------------create_arr()
    T** create_arr(int r, int c)
    {   T** _arr;
        
        _arr = new T*[r];
        FORi(r)
        {   _arr[i] = new T[c];
        }
 
        return _arr;
    }
    
    //--------------------------------------------------------------delete_arr()
    void delete_arr(T**& p)
    {   FORi(row)
        {   delete[] p[i];
        }
        delete[] p;
        p = NULL;
    }
    
};
 
int rrand(int range_max, int range_min)
{   return rand() % (range_max - range_min + 1) + range_min;
}
 
template<class T>
T input_user(const char* promt, T& my)
{   std::cout << promt << " ";
 
    while(!(std::cin>>my) || std::cin.get() != '\n')
    {   std::cout<<"Incorrect input!\n";
        std::cin.clear();
        std::cin.sync();
    }
    return my;
}
    
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{
    setlocale(0, "");
 
    int col = input_user("Количество столбцов: ", col);
    int row = input_user("Количество рядов   : ", row);
 
    carr<int> matrix(row, col);
 
    std::cout << ///-----------------------------------------------------------|
        "///----------------------------------|\n" <<
        "/// Рандомно заполняем.              |\n" <<
        "///----------------------------------:\n";
    srand(static_cast<unsigned int>(time(NULL)));
    FORi(row)
    {   FORj(col)
        {   matrix[i][j] = rrand(20, -20);
        }
    }
    matrix.show();
 
    std::cout << ///-----------------------------------------------------------|
        "///----------------------------------|\n" <<
        "/// Заполняем числом следования.     |\n" <<
        "///----------------------------------:\n";
    int n = 0;
    FORi(row)
    {   FORj(col)
        {   matrix[i][j] = n++;
        }
    }
    matrix.show();
 
    std::cout <<
    "/// Крутонем массив на 90 градусов по часовой-------------------------:\n";
    matrix.rot();
    matrix.show();
 
    std::cout <<
    "/// Крутонем ещё раз(массив к верху ногами)---------------------------:\n";
    matrix.rot();
    matrix.show();
    
    PAUSE;
    return 0;
}
 
#undef FORi
#undef FORj

#include <iostream>
#include <cstdlib>
#include <ctime>
 
using namespace std;
 
inline int rand(int min, int max)
{
    return rand() % (max - min + 1) + min;
}
 
int main()
{
    // Для рандома
    srand(unsigned(std::time(0)));
    const int rand_min = -20;
    const int rand_max = 20;
 
    // Запрашиваем размер матрицы
    int rows;
    int columns;
 
    cout << "Matrix rows: "; cin >> rows;
    cout << "Matrix columns: "; cin >> columns;
 
    // Заполняем
    printf("Original matrix [%dx%d]:\n", rows, columns);
    int **matrix_rows = new int *[rows];
 
    for (int r = 0; r < rows; r++) {
        int *matrix_columns = new int[columns];
 
        for (int c = 0; c < columns; c++) {
            matrix_columns[c] = rand(rand_min, rand_max);
            printf("%d\t", matrix_columns[c]);
        }
 
        matrix_rows[r] = matrix_columns;
        printf("\n");
    }
 
    // Поворачиваем на 90
    int rows90 = columns;
    int columns90 = rows;
 
    printf("\nRotated matrix [%dx%d]:\n", rows90, columns90);
    int **matrix90_rows = new int *[columns];
 
    for (int r = 0; r < rows90; r++) {
        int *matrix90_columns = new int[columns90];
 
        for (int c = 0; c < columns90; c++) {
            matrix90_columns[c] = matrix_rows[c][r];
            printf("%d\t", matrix90_columns[c]);
            //printf("[%dx%d]\t", r, c);
        }
 
        matrix90_rows[r] = matrix90_columns;
        printf("\n");
    }
 
    // Освобождаем память
    for (int r = 0; r < rows; r++) {
        delete [] matrix_rows[r];
    }
    delete [] matrix_rows;
 
    for (int r = 0; r < rows90; r++) {
        delete [] matrix90_rows[r];
    }
    delete [] matrix90_rows;
 
    return 0;
}