Добавить в конец матрицы новую строку чисел

///----------------------------------------------------------------------------|
/// Тема: «Добавить в конец матрицы новую строку чисел.»
/// DevC++ GCC8.2
///----------------------------------------------------------------------------:
#include <iostream>
#include <ctime>
#include <stdlib.h>
#include <iomanip>
 
#define FORi(n) for(int i = 0; i < n; ++i)
#define FORj(n) for(int j = 0; j < n; ++j)
#define LOG(n)  std::cout  << std::setw(6) << #n << " = " << n << "\n"
#define BANNER  std::cout <<
 
struct smystart
{   smystart()
    {   setlocale(0, "");
        system("mode 80,50");
        srand(time(NULL));
    }
}mystart;
 
///----------------------------------------------------------------------------|
/// ВВод с защитой от дурака.
///----------------------------------------------------------------------------:
template<class T>
    T input_user(const char* promt, int n= -1)
    {   std::cout << promt << " ";
        if(n != -1) std::cout << "[" << n <<"] : ";
        T my;
        while(!(std::cin>>my) || std::cin.get() != '\n')
        {   std::cout << "Incorrect input!\n\n";
            std::cout << promt << " ";
            std::cin.clear();
            std::cin.sync();
        }
        return my;
    }
 
///----------------------------------------------------------------------------|
/// Двумерный динамический массив инкапсулированный в структуре.
///----------------------------------------------------------------------------:
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;
    }
    
    int row_()
    {   return row;
    }
    int column_()
    {   return column;
    }
    
    //-----------------------------------------------------------Вывод на экран:
    void show()
    {   std::cout << "\n";
        LOG(row);
        LOG(column);
        FORi(row)
        {   FORj(column)
            {   if(arr[i][j] != -777)
                std::cout << std::setw(5) 
                          << std::setprecision(4) 
                          << std::setfill(' ') << arr[i][j] << " \t";
                else 
                std::cout << std::setw(5) 
                          << std::setprecision(4) 
                          << std::setfill(' ') << " empty\t";
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
 
    T* operator [](const int i)const {return arr[i];}
    
    void init_rand(int border_start, int border_end)
    {   if (border_start > border_end) std::swap(border_start, border_end);
        FORi(row)
            FORj(column)
                arr[i][j] = rrand(border_end, border_start);
    }
    
protected:
    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 = 0)
    {   return rand() % (range_max - range_min + 1) + range_min;
    }
};
 
///----------------------------------------------------------------------------|
/// Модерируем carr под задачу.
///----------------------------------------------------------------------------:
template<class T>
class cmymatrix : public carr<T>
{
public:
    cmymatrix(int r, int c) : carr<T>(r, c) {}
    
    using carr<T>::row;
    using carr<T>::column;
    using carr<T>::arr;
    
    void add_str_numbers()
    {   
        BANNER
        "\n///----------------------------------------------|"<<
        "\n/// Добавить в конец матрицы новую строку чисел. |"<<
        "\n///----------------------------------------------:\n";
        
        T** p_ = carr<T>::create_arr(row + 1, column);
        
        FORi(row)
        {   FORj(column)
            {   p_[i][j] = arr[i][j];
            }
        }
    
        carr<T>::delete_arr(carr<T>::arr);
        arr = p_;
        
        FORi(column)
        {   arr[row][i] = 
                input_user<int>("Введите число для столбца:", i);
        }
        row++;
    }
};
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{   
    int columns = input_user<int>("Введитте количество чисел в строке:");
    int row     = input_user<int>("Введитте количество cтрок         :");
    
    BANNER
        "\n///---------------------------------------------------------|"<<
        "\n/// Матрица с рандомными значениями из заданного диапазона. |"<<
        "\n///---------------------------------------------------------:\n";
    cmymatrix<int> matrix(row, columns);
    matrix.init_rand(-20, 20);
    matrix[0][0] = 2019;
    
    
    while(true)
    {   matrix.show();
        matrix.add_str_numbers();
    }
 
    std::cin.get();
    return 0;
}