Laboratorium nr 11
Temat: Przeciążanie operatorów.
1. Koncepcja przeciążania operatorów w C++
W C++ można przeciążać istniejące operatory, to znaczy nadawać im nowe znaczenie dla operacji
wykonywanych częściowo lub w całości na obiektach typu klasa. Aby przeciążyć operator, np.  + ,
definiuje się funkcję o nazwie operator +, przy czym funkcje te muszą być funkcjami składowymi albo
zaprzyjaz
nionymi z obiektami, na których działają
class klasa{
&
public:
klasa operator +();
&
}
W C++ można przeciążać zarówno operatory jednoargumentowe (np. ++) jak i dwuargumentowe
(+). Należy przy tym ograniczyć się do przeciążania istniejących operatorów, przy zachowaniu
odpowiedniej liczby argumentów. Zwykle funkcja operatora zwraca typ obiektu, na którym działa.
Uwaga: do funkcji zaprzyjaz
nionych nie jest przesyłany wskaz
nik this, dlatego też operatory powinny
być wówczas zadeklarowane jako referencyjne  wówczas przekazywany jest sam obiekt, a nie jego
kopia.
# include
# include
# include
# include
# include
using namespace std;
class macierz {
float *tab;
static int licznik;
public:
int x,y;
void wyswietl();
void wprowadz(int n, int m, float w);
macierz operator++(void);
int operator==(macierz m);
macierz * operator+(macierz m);
friend macierz * operator^(const class macierz &, float p);
macierz(int n=0, int m=0, float w=0);
~macierz();
};
int macierz::licznik=0;
void macierz::wyswietl(){
cout << "\nMacierz:" << licznik << endl;
for (int i=0; i for (int j=0; jtab+y*i+j) << "\t";
cout <<"\n";
};
};
void macierz::wprowadz (int n, int m, float w) {
*(this->tab+y*n+m)=w;
};
macierz macierz::operator++(void){
licznik++;
return *this;
};
int macierz::operator==(macierz m){
if ((m.x==this->x)&&(m.y==this->y)) return 1;
else return 0;
};
macierz * macierz::operator+(macierz m){
class macierz *tmp;
tmp=new macierz(m.x,m.y);
for(int i=0; i for(int j=0; j *(tmp->tab+tmp->y*i+j)=*(this->tab+this->y*i+j)+*(m.tab+m.y*i+j);
return tmp;
};
macierz::macierz(int n, int m, float w){
x=n;
y=m;
tab=new float[n*m];
for (int i=0; i for (int j=0; j *(tab+y*i+j)=w;
}
macierz::~macierz(){
};
macierz * operator^(const class macierz &m1, float p){
class macierz *tmp;
tmp=new macierz(m1.x,m1.y);
for(int i=0; i for(int j=0; j *(tmp->tab+tmp->y*i+j)=pow(*(m1.tab+m1.y*i+j),p);
return tmp;
};
int main() {
class macierz A(2,2,2),B(2,2,3),C(3,3),*D,*E;
++A;
A.wyswietl();
B.wyswietl();
C.wyswietl();
if (A==C) D=A+C; else cout << "\nA+C:Blad\n";
if (A==B) D=A+B; else cout << "\nA+B:Blad\n";
D->wyswietl();
E=A^3;
E->wyswietl();
system("PAUSE");
delete &A,&B,&C,D,E;
return 0;
}
2. Zadanie:
Zmodyfikuj powyższy program tak, aby umożliwiał deklaracje szeregu macierzy o dowolnych
wymiarach oraz podstawowe działania na macierzach (dodawanie, mnożenie, transpozycja, itp.) z
wykorzystaniem operatorów przeciążonych.
Uwaga:
" Program powinien składać się z oddzielnych plików, tzn. pliku głównego oraz plików
zdefiniowanych klas, itp.
" Program powinien posiadać szereg zabezpieczeń, np. sprawdzanie czy wybrane macierzy mają
odpowiednie wymiary oraz czy istnieje przestrzeń na utworzenie kolejnej macierzy, itp.
Program powinien posiadać krótkie menu wyboru, np.:
1. Utwórz macierz
2. Wyświetl macierz
3. Wypełnij macierz  dane losowe
4. Dodaj macierze
5. Pomnóż macierze
6. itp.
7. Koniec