Witam, jako projekt semestralny mam napisać program o tematyce dowolnej, musi być napisany obiektowo, zawierać przeciążane operatory i dziedziczenie. Mój pomysł to działania na macierzach. Po kilku(może nawet nasto) godzinnej walce mam coś takiego:
#include <iostream>
using namespace std;
class macierz
{
public:
//zmienne
int wiersze;
int kolumny;
double **tablica; //wskaznik na dynamiczna tablice (macierz)
//konstruktory i destruktory
macierz(int wiersze, int kolumny); //konstruktor dwuparametrowy
macierz(); //konstruktor domyslny
~macierz(){delete []tablica;} //destruktor domyslny
macierz(macierz const &m); //konstruktor kopiujacy
//zaprzyjaznione operatory przeciazane
friend macierz operator+(const macierz &m1, const macierz &m2);
friend macierz operator-(const macierz &m1, const macierz &m2);
friend macierz operator*(const macierz &m1, const macierz &m2);
friend macierz operator*(const macierz &m1, const double skalar);
//metody
void Wyswietl()const;
};
///////////////////////////////////////////////////////////////////////////////
macierz::macierz () //domyslnie tworzy macierz 2x2 wypelniona zerami
{
wiersze=kolumny=2;
tablica = new double *[wiersze];
for (int i=0; i<wiersze;i++)
tablica[i]=new double[kolumny];
for ( int i = 0; i < kolumny; i ++ )
{
cout<<"wiersz "<<i<<": ";
for (int j=0; j<wiersze; j++)
tablica[i][j] = 0;
}
Wyswietl();
}
////////////////////////////////////////////////////////////////////////////////
macierz::macierz(macierz const &m) //konstruktor kopiujacy
{
kolumny = m.kolumny;
wiersze = m.wiersze;
tablica = new double *[wiersze];
for (int i = 0; i < wiersze; i ++ )
tablica[i] = new double[kolumny];
for (int i = 0; i < wiersze; i ++ )
for (int j = 0; j < kolumny; j ++ )
tablica[i][j] = m.tablica[i][j];
}
///////////////////////////////////////////////////////////////////////////////
macierz::macierz (int wier, int kol) //konstruktor dwuparametrowy
{
kolumny = kol;
wiersze = wier;
double wartosc;
tablica = new double *[wiersze];
for (int i=0; i<wiersze;i++)
tablica[i]=new double[kolumny];
for ( int i = 0; i < wiersze; i ++ )
{ for (int j=0; j<kolumny; j++)
{ cout << "Wprowadz [" << i << "]" << "[" << j << "] element macierzy: ";
cin>>wartosc;
tablica[i][j] = wartosc;
}
}
}
///////////////////////////////////////////////////////////////////////////////
void macierz::Wyswietl()const
{
for ( int i = 0; i < wiersze; i ++ )
{
cout<<endl<<"wiersz "<<i<<": \t";
for (int j=0; j<kolumny; j++)
{
cout<<tablica[i][j]<<" ";
}
}
cout<<endl;
}
//////////////////////////////////////////////////////////////////////////////
macierz::macierz operator+(const macierz &m1, const macierz &m2)
{
macierz m3(m1);
if (m1.wiersze == m2.wiersze && m1.kolumny == m2.kolumny)
{
for (int i=0; i<m3.wiersze; i++)
for (int j=0; j<m3.kolumny; j++)
{
m3.tablica[i][j] += m2.tablica[i][j];
}
}
else
cout<<"Nie mozna dodac macierzy!!\n";
return m3;
}
////////////////////////////////////////////////////////////////////////////////
macierz::macierz operator-(const macierz &m1, const macierz &m2)
{
macierz m3(m1);
if (m1.wiersze == m2.wiersze && m1.kolumny == m2.kolumny)
{
for (int i=0; i<m3.wiersze; i++)
for (int j=0; j<m3.kolumny; j++)
{
m3.tablica[i][j] -= m2.tablica[i][j];
//m3.tab[i][j]=m1[i][j]+m2[i][j]
}
}
else
cout<<"Nie mozna odjac macierzy!!\n";
return m3;
}
///////////////////////////////////////////////////////////////////////////////////
macierz::macierz operator*(const macierz &m1, const macierz &m2)
{
macierz m3(m1);
if (m1.kolumny == m2.wiersze)
{
for (int i = 0; i <m1.wiersze; i++)
for (int j = 0; j <m2.kolumny; j++)
m3.tablica[i][j] = 0;
for(int i = 0; i < m1.wiersze; i++)
for(int j = 0; j < m2.kolumny; j++)
for(int k = 0; k < m2.wiersze; k++)
m3.tablica[i][j] = m3.tablica[i][j] + m1.tablica[i][k] * m2.tablica[k][j];
}
else
cout<<"Nie mozna pomnozyc macierzy!!\n";
return m3;
}
//////////////////////////////////////////////////////////////////////////
macierz::macierz operator*(const macierz &m1, const double skalar)
{
macierz m2(m1);
for (int i = 0; i <m1.wiersze; i++)
for (int j = 0; j <m1.kolumny; j++)
m2.tablica[i][j] = m1.tablica[i][j]*skalar;
return m2;
}
//////////////////////////////////////////////////////////////////////
void wyswietlmenu(){
cout << "Program wykonujacy dzialania na macierzach\n";
cout << "1.Dodaj macierze\n";
cout << "2.Odejmij macierze\n";
cout << "3.Pomnoz macierze (A*B)\n";
cout << "4.Pomnoz przez skalar\n";
cout << "5.Transponuj (tylko dla macierzy kwadratowej)\n";
cout << "6.Wyjscie\n";
cout << "Wybierz wlasciwa opcje\n";
};
///////////////////////////////////////////////////////////////////
int main()
{ wyswietlmenu();
int wybor;
cin >> wybor;
int liczbawierszy;
int liczbakolumn;
switch (wybor){
case 1: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
cin >> liczbawierszy;
cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
cin >> liczbakolumn;
macierz A (liczbawierszy,liczbakolumn);
cout << "Wprowadz liczbe wierszy drugiej macierzy: ";
cin >> liczbawierszy;
cout << "Wprowadz liczbe kolumn drugiej macierzy: ";
cin >> liczbakolumn;
macierz B (liczbawierszy,liczbakolumn);
macierz C=A+(B);
C.Wyswietl(); break;}
//DODAWANIE
case 2: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
cin >> liczbawierszy;
cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
cin >> liczbakolumn;
macierz A (liczbawierszy,liczbakolumn);
cout << "Wprowadz liczbe wierszy drugiej macierzy: ";
cin >> liczbawierszy;
cout << "Wprowadz liczbe kolumn drugiej macierzy: ";
cin >> liczbakolumn;
macierz B (liczbawierszy,liczbakolumn);
macierz C=A-(B);
C.Wyswietl(); break;}//ODEJMOWANIE
case 3: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
cin >> liczbawierszy;
cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
cin >> liczbakolumn;
macierz A (liczbawierszy,liczbakolumn);
cout << "Wprowadz liczbe wierszy drugiej macierzy: ";
cin >> liczbawierszy;
cout << "Wprowadz liczbe kolumn drugiej macierzy: ";
cin >> liczbakolumn;
macierz B (liczbawierszy,liczbakolumn);
macierz C=A*(B);
C.Wyswietl();
break;} //MNOZENIE
case 4: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
cin >> liczbawierszy;
cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
cin >> liczbakolumn;
macierz A (liczbawierszy,liczbakolumn);
cout << "Wprowadz skalar: ";
double skalar;
cin >> skalar;
macierz C=A*(skalar);
C.Wyswietl();
break;}
; //MNOZENIE PRZEZ SKALAR
case 5:break; //TRANSPONOWANIE
case 6:break; //WYJSCIE
default:break ;
};
system ("PAUSE");
return 0;
}
Wiem, że można by to napisać bardziej elegancko, uzyc plikow naglowkowych itd. ale nie o to mi chodzi. chcĘ zeby ktos rzucil okiem na kod i wytknal ewentualne bledy wraz ze sposobem ich poprawy ze szczegolnym naciskiem na przeciazanie operatorow, alokowanie i zwalnianie pamieci jako, ze tego dopiero sie ucze. Zaznaczam, ze program nie jest skonczony bo mam zamiar jeszcze stworzyc klase pochodna macierzy kwadratowej i klase pochodna macierzy jednostkowej. Jest to dopiero szkielet ale chciałbym po prostu wiedziec czy zmierzam w dobrym kierunku. Pozdrawiam, Piotr.