в классе создаётся объект оператором new, как его удалить после использования в основной программе? delete в вызывающей функции не вариант!

//Это типа служебного класса. (Внимание! В оригинальном коде он вложен в класс xx, но я этого не стал делать, дабы не усложнять код!)
class nemo_ {
};
 
//А это вот класс для конечного пользователя
class xx {
 public:
  nemo_& funktsia () {
  nemo_* ne= new nemo_ [1];
  return *ne;
 };
};
 
int main () {
 xx m;
 
 //Так, вот щас создастся объект класса nemo_; а нужен он для того, чтобы выполнился определённый код, который в нём скрывается
 m.funktsia ();
 //Тут пойдёт всякий разный код, и мне объект nemo_ больше не нужен
}

Row< T > *m_matrix;

T** p

matrix_[4][6];

matrix_[4];

 printf ("==  %d\n", sizeof (matrix<int>::nemo));

  class nemo;
  nemo& operator[](int nomer_stroki) {
   nemo* ne= new nemo [1];
   ne->k= (T*)(p[nomer_stroki]); 
   return *ne;
  };

matrix<int> y (6, 7);
y[2][4]= 99;

nemo operator[](int nomer_stroki) {
   nemo ne;
   ne.k= (T*)(p[nomer_stroki]); 
   return ne;
  };

matrix<int> y (6, 7);

#include <iostream>
 
// Шаблонный класс "Матрица"
template< typename T >
class Matrix
{
public:
    // Конструктор
    // rows - количество строк
    // cols - количество столбцов
    Matrix(size_t rows = 1, size_t cols = 1):
    m_rows(rows),             // Инициализируем количество строк
    m_cols(cols),             // Инициализирцем количество столбцов
    m_matrix(new T *[m_rows]) // Выделяем память под массив указателей
    {
        // Инициализируем каждый указатель массива отдельно выделенным массивом
        for (size_t i = 0; i < m_rows; ++i)
            m_matrix[i] = new T [m_cols];
    }
 
    // Деструктор
    ~Matrix()
    {
        // Удаляем каждый из массивов, на которые указывают элементы массива
        // указателей
        for (size_t i = 0; i < m_rows; ++i)
            delete [] m_matrix[i];
 
        // Удаляем массив указателей
        delete [] m_matrix;
    }
 
    // Оператор []
    T *operator[](size_t index)
    {
        // Возвращаем соответствующую строку матрицы
        return m_matrix[index];
    }
 
    // Константный оператор [] (аналогично неконстантному)
    const T *operator[](size_t index) const
    {
        return m_matrix[index];
    }
 
private:
    size_t m_rows; // Количество строк матрицы
    size_t m_cols; // Количество столбцов матрицы
    T **m_matrix;  // Сама матрица
};
 
int main()
{
    const size_t rows = 2;
    const size_t cols = 2;
 
    Matrix< double > m(rows, cols);
 
    for (size_t i = 0; i < rows; ++i)
        for (size_t j = 0; j < cols; ++j)
            m[i][j] = i + j;
 
    for (size_t i = 0; i < rows; ++i)
    {
        for (size_t j = 0; j < cols; ++j)
            std::cout << m[i][j] << "  ";
 
        std::cout << std::endl;
    }
 
    return 0;
}

  T* operator[](int nomer_stroki) {
   return p[nomer_stroki];
  };

#include <iostream>
 
// Шаблонный класс "Матрица"
template< typename T >
class Matrix
{
public:
    // Конструктор
    // rows - количество строк
    // cols - количество столбцов
    Matrix(size_t rows = 1, size_t cols = 1):
    m_rows(rows),             // Инициализируем количество строк
    m_cols(cols),             // Инициализирцем количество столбцов
    m_matrix(new T *[m_rows]) // Выделяем память под массив указателей
    {
        // Инициализируем каждый указатель массива отдельно выделенным массивом
        for (size_t i = 0; i < m_rows; ++i)
            m_matrix[i] = new T [m_cols];
    }
 
    // Деструктор
    ~Matrix()
    {
        // Удаляем каждый из массивов, на которые указывают элементы массива
        // указателей
        for (size_t i = 0; i < m_rows; ++i)
            delete [] m_matrix[i];
 
        // Удаляем массив указателей
        delete [] m_matrix;
    }
 
    //+++++++++++++++++Вот это++++++++++++++++++++
    operator T**() {return m_matrix;};
 
private:
    size_t m_rows; // Количество строк матрицы
    size_t m_cols; // Количество столбцов матрицы
    T **m_matrix;  // Сама матрица
};
 
int main()
{
    const size_t rows = 2;
    const size_t cols = 2;
 
    Matrix< double > m(rows, cols);
 
    for (size_t i = 0; i < rows; ++i)
        for (size_t j = 0; j < cols; ++j)
            m[i][j] = i + j;
 
    for (size_t i = 0; i < rows; ++i)
    {
        for (size_t j = 0; j < cols; ++j)
            std::cout << m[i][j] << "  ";
 
        std::cout << std::endl;
    }
     getchar ();
    return 0;
}

#include <iostream>
 
template< typename T >
class Matrix
{
public:
    Matrix(size_t rows = 1, size_t cols = 1):
    m_rows(rows),
    m_cols(cols),
    m_matrix(new T *[m_rows])
    {
        for (size_t i = 0; i < m_rows; ++i)
            m_matrix[i] = new T [m_cols];
    }
 
    ~Matrix()
    {
        for (size_t i = 0; i < m_rows; ++i)
            delete [] m_matrix[i];
 
        delete [] m_matrix;
    }
 
    T &operator()(size_t v_index, size_t h_index)
    {
        return m_matrix[v_index][h_index];
    }
 
    const T &operator()(size_t v_index, size_t h_index) const
    {
        return m_matrix[v_index][h_index];
    }
 
private:
    size_t m_rows;
    size_t m_cols;
    T **m_matrix;
};
 
int main()
{
    const size_t rows = 2;
    const size_t cols = 2;
 
    Matrix< double > m(rows, cols);
 
    for (size_t i = 0; i < rows; ++i)
        for (size_t j = 0; j < cols; ++j)
            m(i, j) = i + j;
 
    for (size_t i = 0; i < rows; ++i)
    {
        for (size_t j = 0; j < cols; ++j)
            std::cout << m(i, j) << "  ";
 
        std::cout << std::endl;
    }
 
    return 0;
}