Разобраться с использованием класса

#include <assert.h>
template <class H>H RanDD(H x){return (H)(random(x)-random(x)+1);};
template <class H>
class Matrix
{
  private:
     H **matrix, **tmatrix;
     H aaa, TEMP, Nevyazka;
     int SIZE;
     void Perestanovka(H*,H*);
     long Count;
     public:
      Matrix(int,H);
      ~Matrix();
     H ** PtrM(){return matrix;}
     bool Initial(H(*fff)(H)){for(int i=0;i<SIZE;i++)for(int j=0;j<SIZE;j++)matrix[i][j]=fff(aaa);return true;};
     bool Initial();
     H Insert(int n,int m){return matrix[n][m];};
     H InsertT(int n,int m){return tmatrix[n][m];};
     long count(){return Count;};
     void count(long a){ Count = a;};
     H nevyazka(){return Nevyazka;};
     bool Add(H a,int n,int m){matrix[n][m]=a;return true;};// добавляет в матрицу
     bool AddA(H a,int n){array[n]=a;   return true;};// добавляет в массив
     bool Multiplying();
     bool Transpon();
     int Faddeev();
     H Sled(H**);
};
//==============================================================================
// обращение матрицы методом фаддеева
template<class H>
int Matrix<H>::Faddeev()
{
     H **EDIN = new H*[SIZE], sled,ppp;
     H **BBB = new H*[SIZE];
//     H **PPP = new H*[SIZE];
     assert(EDIN !=0);
     assert(BBB !=0);
// создаю единичную матрицу
     for(int i=0;i<SIZE;i++)
      {
       EDIN[i]=new H[SIZE];
       BBB[i]=new H[SIZE];
       for(int j=0;j<SIZE;j++)
         {
          if(i==j)EDIN[i][j]=1;
          else EDIN[i][j]=0;
          tmatrix[i][j] = matrix[i][j];
         }
      }
     for(int i=0;i<SIZE-1;i++)
      {
        sled = Sled(tmatrix);
        ppp=(sled/(i+1));
        for(int g=0;g<SIZE;g++)
          for(int f=0;f<SIZE;f++)
            { BBB[g][f]=tmatrix[g][f]-EDIN[g][f]*ppp;Count++;}
        for(int qq=0;qq<SIZE;qq++)
          for(int ww=0;ww<SIZE;ww++)
              {tmatrix[qq][ww]=0;
               for(int kk=0;kk<SIZE;kk++)
                  {
                    tmatrix[qq][ww] += matrix[qq][kk]*BBB[kk][ww];
                    Count++;
                  }
              }
      }
     sled = Sled(tmatrix);
     ppp=(sled/(SIZE));
     for(int qq=0;qq<SIZE;qq++)
       for(int ww=0;ww<SIZE;ww++)
           tmatrix[qq][ww]=BBB[qq][ww]/ppp;
 
     Nevyazka = 0;
     for(int qq=0;qq<SIZE;qq++)Nevyazka+=(matrix[qq][SIZE-1]-tmatrix[qq][SIZE-1])*(matrix[qq][SIZE-1]-tmatrix[qq][SIZE-1]);
     Nevyazka = sqrt(Nevyazka)/(SIZE-1);
 
     for(int i=0;i<SIZE;i++){delete[]EDIN [i];delete[]BBB [i];}
     delete[]BBB;
     delete[]EDIN;
   return 1;
}
template<class H>
bool Matrix<H>::Initial()
{
     H **UM = new H*[SIZE];
     H **DM = new H*[SIZE];
     assert(UM !=0);assert(DM !=0);
     for(int i=0;i<SIZE;i++)
      {
       UM[i] = new H[SIZE];
       DM[i] = new H[SIZE];
       for(int j=0;j<SIZE;j++)
         {
           if(j<=i) DM[i][j]=(random(aaa)+1)*pow(-1,random(1));
           else     DM[i][j]=0;
           if(j<i)  UM[i][j]=0;
           else     UM[i][j]=(random(aaa)+1)*pow(-1,random(1));
           Count+=4;
         }
      }
     for(int i=0;i<SIZE;i++)
      for(int j=0;j<SIZE;j++){matrix[i][j]=0;Count++;
        for(int k=0;k<SIZE;k++)
            {matrix[i][j] += UM[i][k]*DM[k][j];Count++;}}
     for(int i=0;i<SIZE;i++){delete[]DM[i];delete[]UM[i];}
     delete[]UM;
     delete[]DM;
   return 1;
}
//==============================================================================
//  считает след матрицы приведённой к треуголному виду
//  перед вызововм необходимо использовать PrivedUp2()
template<class H>
H Matrix<H>::Sled(H**matr)
{
 H temp1=0;
 for(int h=0;h<SIZE;h++)
  {
    temp1+=matr[h][h];
  }
 return temp1;
}
//==============================================================================
//
template<class H>
Matrix<H>::Matrix(int size,H a)
{
   SIZE = size; aaa = a; Count = 0;
   if(SIZE)
    {
     matrix = new H*[SIZE];
     assert(matrix!=0);
     tmatrix = new H*[SIZE];
     assert(tmatrix!=0);
     for(int i=0;i<SIZE;i++)
      {
       matrix[i]=new H[SIZE];
       assert(matrix!=0);
       tmatrix[i]=new H[SIZE];
       assert(tmatrix!=0);
      }
    }
};
template<class H>
Matrix<H>::~Matrix()
{ if(SIZE)
    {
     for(int i=0;i<SIZE;i++)
      {
       delete[]matrix[i];
       delete[]tmatrix[i];
      }
     delete[]matrix;
     delete[]tmatrix;
    }
 
};

Matrix<float> m();

#include "TTemp.h" //сюда я запихал код матрицы
 
int main()
{
    Matrix<int> test(10, 10); //вот так создал объект
}

Matrix<float> m()
{
  return Matrix<float>(10, 10);
}

Matrix<float> matrix = m();
matrix.___