macierze na klasach???

Witam, mam taki problem, napisalem taki programik do obliczeń na macierzach,(troche w nim bałaganu) ale potrzebuje mniej wiecej to samo zrobić na klasach, i tu jest problem bo nie bardzo je rozumiem. Jak mój program wpakowac do klasy, jak sie za to zabrac, te konstruktory itp:
A oto ten mój programik:

#include <iostream.h>
#include <conio.h>
#include<iomanip>
//--------------------------------------------------------------------------
main()
{
//--------------------------------------------------------------------------
/ustalenie wielkosci i tworzenie macierzy kwadratowych/

        int w, k, D;

                    cout<<"Podaj wielkosc macierzy kwadratowych A i B: ";
                    cin>>w;
                    k=w;

            float **A;
            A = new float *[w];

            cout<<"\n\n-------------------\n";
            cout<<"Tworzenie macierzyA:\n";
            cout<<"-------------------\n\n";

            for(int i=0; i<w; i++)
            {
                    A[i] = new float [k];
                    for(int j=0; j<k; j++)
                    {
                    cout<<"Podaj wartosc ["<<(i+1)<<","<<(j+1)<<"]: ";
                            cin>>A[i][j];

                    }

            }

            for(int i=0; i<w; i++ , cout<<endl)
               for(int j=0; j<k; j++)
                   cout<<setw(3)<<A[i][j];



        float **B;
            B = new float *[w];

            cout<<"\n\n-------------------\n";
            cout<<"Tworzenie macierzyB:\n";
            cout<<"-------------------\n\n";

            for(int i=0; i<w; i++)
            {
                    B[i] = new float [k];
                    for(int j=0; j<k; j++)
                    {
                            cout<<"Podaj wartosc ["<<(i+1)<<","<<(j+1)<<"]: ";
                            cin>>B[i][j];

                    }

            }

            for(int i=0; i<w; i++ , cout<<endl)
               for(int j=0; j<k; j++)
                   cout<<setw(3)<<B[i][j];

/---------------------------------------------------------------------------/
cout<<"zerwanie macierzy C"<<endl;

float **C;
C = new float *[w];

            for(int i=0; i<w; i++)
            {
                    C[i] = new float [k];
                    for(int j=0; j<k; j++)
                    {

                            C[i][j]=0;

                    }

            }
                   

            for(int i=0; i<w; i++ , cout<<endl)
               for(int j=0; j<k; j++)
                   cout<<setw(3)<<C[i][j];

//---------------------------------------------------------

          cout<<"wyswietlanie macierzy C=A+B"<<endl;




           for(int i=0; i<w; i++, cout<<endl)
             for(int j=0; j<k; j++)
                C[i][j]=A[i][j]+B[i][j];

                for(int i=0; i<w; i++ , cout<<endl)
               for(int j=0; j<k; j++)
                   cout<<setw(3)<<C[i][j];

//---------------------------------------------------------
cout<<"wyswietlanie macierzy C=A*B"<<endl
<<endl ;
cout<<"wyzerowanie macierzy C:"<<endl;
for(int i=0; i<w; i++ , cout<<endl) //zerowanie
for(int j=0; j<k; j++)
C[i][j]=0;
cout<<endl;

                  for(int i=0; i<w; i++ , cout<<endl)  //
               for(int j=0; j<k; j++)
                   cout<<setw(3)<<C[i][j];

        cout<<"macierz przemnożona:"<<endl;
             //Mnozenie macierzy

for(int i=0;i<w;i++)//wiersze macierzy A
for(int j=0;j<k;j++)//kolumny macierzy B
for(int s=0;s<k;s++)//kolumny macierzy A=wiersze macierzy B
C[i][j]=C[i][j]+A[i][s]*B[s][j];

                for(int i=0; i<w; i++ , cout<<endl)
               for(int j=0; j<k; j++)
                   cout<<setw(3)<<C[i][j];


          
                   getch();
             }

//---------------------------------------------------------------------------

Muszę przyznać, że twojego kodu nie analizowałem ale...
swego czasu zrobiłem macierzze na klasach i choć nie mogę teraz tego się doszukać, to:

• do konstruktora podawało się wymiary np MACIERZ *m =new MACIERZ(10,10), a ten dopiero w swoim wnętrzu zajmował miejsce dla pamięci przy pomocy "new" i zapisywał w polach wymiary macierzy,
• destruktor misiał zwalniać tak przydzieloną pamięć,
• oczywiście do klas dołączone były odpowiednie operatory (mnożenie macierzy i przez skalar, suma).

jak coś pomogło to proszę bardzo.

Oto przykład działań na macieżach 2 na 2 zbudowany na klasach może coś pomoże

#include <iostream.h>
#include <conio.h>

class CM22
{
 public:

 int tablica[2][2];

 CM22(void);                    //konstruktor difoltowy
 CM22(int a,int b,int c,int d); //konstruktor
 void drukuj(void);             //funkcja wypisujaca na ekran


};


CM22::CM22(int a,int b,int c,int d)    //definicja konstruktora
{
 tablica[0][0]=a;
 tablica[0][1]=b;
 tablica[1][0]=c;
 tablica[1][1]=d;
}

CM22::CM22(void)
{
 tablica[0][0]=0;
 tablica[0][1]=0;
 tablica[1][0]=0;
 tablica[1][1]=0;
}

void CM22::drukuj(void)        //definicja funkcji wypisujacej na ekran
{
 for(int i=0;i<2;i++)
 {
  cout<<endl;
	for(int j=0;j<2;j++)
	{
	 cout<<tablica[i][j]<<" ";
	}
 }
 cout<<endl;
}

CM22 operator+(CM22 o,CM22 p)   //przeladowanie operatora +
{
 CM22 r;
 r.tablica[0][0]=o.tablica[0][0]+p.tablica[0][0];
 r.tablica[0][1]=o.tablica[0][1]+p.tablica[0][1];
 r.tablica[1][0]=o.tablica[1][0]+p.tablica[1][0];
 r.tablica[1][1]=o.tablica[1][1]+p.tablica[1][1];

 return r;
}

CM22 operator-(CM22 o,CM22 p)   //przeladowanie operatora -
{
 CM22 r;
 r.tablica[0][0]=o.tablica[0][0]-p.tablica[0][0];
 r.tablica[0][1]=o.tablica[0][1]-p.tablica[0][1];
 r.tablica[1][0]=o.tablica[1][0]-p.tablica[1][0];
 r.tablica[1][1]=o.tablica[1][1]-p.tablica[1][1];

 return r;
}

CM22 operator*(CM22 o,CM22 p)	//przeladowanie operatora *
{
 CM22 r;
 r.tablica[0][0]=o.tablica[0][0]*p.tablica[0][0]+o.tablica[0][1]*p.tablica[1][0];
 r.tablica[0][1]=o.tablica[0][0]*p.tablica[0][1]+o.tablica[0][1]*p.tablica[1][1];
 r.tablica[1][0]=o.tablica[1][0]*p.tablica[0][0]+o.tablica[1][1]*p.tablica[1][0];
 r.tablica[1][1]=o.tablica[1][0]*p.tablica[0][1]+o.tablica[1][1]*p.tablica[1][1];

 return r;
}

void main(void)
{
 clrscr();

 CM22 m1(1,2,3,4); //obiekt klasy CM22
 CM22 m2(2,3,4,5);
 CM22 m3;

 cout<<"Macierz pierwsza to:"<<endl;
 m1.drukuj(); //wywolanie funkcji drukuj dla obiektu m1

 cout<<"Macierz druga to:"<<endl;
 m2.drukuj();

 m3=m1+m2;    //dodawanie macierzy

 cout<<"Suma macierzy to:"<<endl;
 m3.drukuj();

 cout<<"Roznica macierzy to:"<<endl;
 m3=m1-m2;    //odejmowanie macierzy
 m3.drukuj();

 cout<<"Iloczyn macierzy to;"<<endl;
 m3=m1*m2;
 m3.drukuj();

 getch();

}

najlepiej zrob jak Bucz mowi:

class Matrix{
double **m;
int wiersze, kolumny;
Matrix(int w, int k){
// przydzielenie pamieci dla macierzy o rozmiarze w x k
}
~Matrix(){
// zwolnienie pamieci
}
Matrix& operator+(const Matrix& m2){
// dodawanie macierzy m + m2
}
Matrix& operator=(const Matrix& m2){
// przypisanie
}
};

przeladuj odpowiednie operatory i masz wszytko czego potrzebujesz.
mozesz wtedy wygodnie korzystac z takiej biblioteki:

Matrix a(10,10);
Matrix b(10, 10);
Matrix c(10,10);

c = a + b;