Если применять эту функцию к массиву, то он будет удаляться без всяких утечек памяти и т.п.?

//Функция удаления двумерного массива
void delete_array(int** arr, int row)
{
    for (int i = 0; i < row; i++)
    {
        delete[] arr[i];
    }
    delete[] arr;
}

#include <iostream>
 
///----------------------------------------------------------------------------|
/// Макросы для удобства.
///----------------------------------------------------------------------------:
#define SHOWVAL(v) std::cout << #v << " = "<< 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)
    {   create_arr();
    }
    
   ~carr()
    {   delete_arr();
    }
    
    //------------------------------------------------------resize(int r, int c)
    void resize(int _r, int _c)
    {   row    = _r;
        column = _c;
        create_arr();
    }
    
    //-----------------------------------------------------------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;
    }
    
    //---------------------------------------------------------get(int r, int c)
    T get(int _r, int _c)
    {   return arr[_r][_c];
    }
    
    //--------------------------------------------------------------------show()
    void show()
    {   std::cout << "\n\n";
        SHOWVAL(row);
        SHOWVAL(column);
        FORi(row)
        {   FORj(column)
            {   std::cout << arr[i][j] << "\t";
            }
            std::cout << "\n";
        }
    }
    
    T* operator [](const int i)const {return arr[i];}
    
T** arr;        // Почему тут будет плохо?
private:
    //T** arr;  // А здесь будет хорошо!
    
    int row, column;
    
    //--------------------------------------------------------------create_arr()
    void create_arr()
    {   if(arr != NULL) delete_arr();
        arr = new T*[row];
        FORi(row)
        {   arr[i] = new T[column];
        }
    }
    
    //--------------------------------------------------------------delete_arr()
    void delete_arr()
    {   FORi(row)
        {   delete[] arr[i];
        }
        delete[] arr;
        arr = NULL;
    }
    
};
#undef FORi
#undef FORj
    
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   
    int** arr2;
    
    {
        carr<int> matrix(3,4);
        matrix.init_one(0);
        matrix.show();
        
        matrix.resize(5, 6);
        matrix.init_one(2019);
        matrix.show();
    
        matrix.set(0, 1, 1945);
        SHOWVAL(matrix.get(0,1));
        matrix.show();
        
        arr2 = matrix.arr;   // Передали внаружу.(публичный arr это позволит)
                             // Если бы arr был приватный, то ошибка была бы
                             // отловлена на этапе компиляции.
        
        SHOWVAL(arr2[0][1]); // Пока внутри все хорошо.
        
        ///-----------------------------|
        /// Тест перегруженных скобок:  |
        //------------------------------|
        matrix[3][3] = 0;
        matrix.show();
        matrix[0][0] = matrix[3][3];
        matrix.show();
      ++matrix[0][0] += 2;
        matrix.show(); // для элемента(0,0) результат = 3
    }
    
    // Здесь объект matrix будет уничтожен и вся память выделенная в нем будет
    // освобождена!
    
    //arr2 - висячий указатель!!!
    SHOWVAL(arr2[0][1]);     // Тут фейл!
                             // Поэтому arr надо сделать приватным!
    PAUSE;
    return 0;
}