в классе создаётся объект оператором 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_ больше не нужен
}

#include <iostream>
 
using namespace std;
 
class A
{
public:
    A()           { cout << "I'm default ctor\n"; }
    ~A()          { cout << "I'm destructor\n"; }
};
 
A g () {
 A a;
 return a;
} 
 
int main() {
    g ();
    getchar();
    return 0;
}

#include <iostream>
 
using namespace std;
 
class A
{
public:
    A()           { cout << "I'm default ctor\n"; }
    ~A()          { cout << "I'm destructor\n"; }
};
 
A g () {
 A a;
 return a;
} 
 
int main() {
    g ();
    getchar();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <typeinfo>
#include <time.h>
 
template <class T>
class matrix {
 public:
 
  //Кнструтор по умолчанию создаёт матрицу из 2-х строк и одного столбца; ничем не инициализирует
  matrix () {srand (time(0));kol_vo_strok= 2; kol_vo_stolb= 1;};        
 
  //Конструктор просто создаёт матрицу, выделяет место под строи и столбцы, но не инициализирует их
  //В деструкторе, понятно, эта память освободится
  matrix (int x, int y):kol_vo_strok(x), kol_vo_stolb(y) {
   srand (time(0));
   p= new T* [x];
   for (int i= 0; i< x; i++) {
    p[i]= new T [y];
   }
  };        
 
 
  //А это деструктор, освобождает на хер всю занятую память
  ~matrix () {
   for (int i= 0; i< kol_vo_strok; i++)
    delete [] p[i];
    delete [] p;
   };        
 
  //Инициализация матрицы рандомно значениями от x до y влючительно
  //если значения типа double, то тоже будет всё нормально, после запятой будет два знака
  void init_rand (int x, int y) {
   double temp;
   for (int i= 0; i< get_kol_vo_strok(); i++) {
    for (int j = 0; j< get_kol_vo_stolb(); j++) {
     p[i][j]= rand()%(y- x+ 1)+ x;
     if (typeid(p[i][j])== typeid (temp)) {
      if (p[i][j]!= y) {
       p[i][j]+= (T)rand()/(RAND_MAX+1);;
      }
     }
    }
   }
  }
 
 
  //Это вот вывод матрицы
  void vivod () {
   double temp;
   for (int i= 0; i< get_kol_vo_strok(); i++) {
    for (int j = 0; j< get_kol_vo_stolb(); j++) {
     if (typeid(p[i][j])== typeid (temp))
      printf ("%.2f ", (double)p[i][j]);  
     else
      printf ("%3d ", p[i][j]);  
    }
    printf ("\n");
   }
  }
 
 
 
  //Устанавливает количество строк
  void set_kol_vo_strok (T x) {kol_vo_strok= x;};
  //... и количество столбцов
  void set_kol_vo_stolb (T x) {kol_vo_stolb= x;}
 
 
  //Возвращаает количество строк
  int get_kol_vo_strok () {return kol_vo_strok;};
  //... и количество столбцов
  int get_kol_vo_stolb () {return kol_vo_stolb;}
 
  
  //Перегрузка операторов
  //Это перегрузка оператора []; работает пока но этого мало, надо чтобы была перегрузка [][]  
 
  class nemo {
   public:
    T* k;   
    T& operator[](int nomer_stolbtsa) {
     return (k[nomer_stolbtsa]);
    };
  };
  
  //А вот из этой функции возвращается объект класса nemo. 
  //ПОка возвращается ссыль, но я буду переделывать, чтобы возвращался объект.
  nemo& operator[](int nomer_stroki) {
   nemo* ne= new nemo [1];
   ne->k= (T*)(p[nomer_stroki]); 
   return *ne;
  };
  
 
 
 
 private:
 
  //Количество строк, количество столбцов
  int kol_vo_strok;         
  int kol_vo_stolb;         
 
 
// public:
  //Динамический мссив из указателей на указатели на T
  T**p;
 
 
};
 
 
int main () {
 
 matrix<int> y (6, 7);
 y.init_rand (1, 100);
 y.vivod();
 printf ("\n");  
 
 //Благодаря моей дури, эта херь корректна:
 printf ("%d\n", y[3][4]);  
 y[3][4]= 99;
 
 y.vivod();
 printf ("\n");  
 
 getchar (); 
 
}

struct tip {
 //куча полей
}

T** p;

#include <iostream>
 
template< typename T >
class Row
{
public:
    Row(size_t size = 1):
    m_size(size),
    m_row(new T [m_size])
    {
        for (size_t i = 0; i < m_size; ++i)
            m_row[i] = 0.0;
    }
 
    Row(const Row &source):
    m_size(source.m_size),
    m_row(new T [m_size])
    {
        for (size_t i = 0; i < m_size; ++i)
            m_row[i] = source.m_row[i];
    }
 
    ~Row()
    {
        delete [] m_row;
    }
 
    void resize(size_t new_size)
    {
        double *new_row = new T [new_size];
 
        for (size_t i = 0; i < m_size; ++i)
            new_row[i] = m_row[i];
 
        for (size_t i = m_size; i < new_size; ++i)
            new_row[i] = 0.0;
        
        delete [] m_row;
 
        m_row = new_row;
        m_size = new_size;
    }
 
    T &operator[](size_t index)
    {
        return m_row[index];
    }
 
    const T &operator[](size_t index) const
    {
        return m_row[index];
    }
 
private:
    size_t m_size;
    T *m_row;
};
 
template< typename T >
class Matrix
{
public:
    Matrix(size_t rows = 1, size_t cols = 1):
    m_rows(rows),
    m_matrix(new Row< T > [m_rows])
    {
        for (size_t i = 0; i < m_rows; ++i)
            m_matrix[i].resize(cols);
    }
 
    ~Matrix()
    {
        delete [] m_matrix;
    }
 
    Row< T > &operator[](size_t index)
    {
        return m_matrix[index];
    }
 
    const Row< T > &operator[](size_t index)const
    {
        return m_matrix[index];
    }
 
private:
    size_t m_rows;
    Row< 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;
}