Listing 7.7. porównanie wektorów – przeciążanie operatorów
1
// d e f i n i c j a z f u n k c j a m i z a p r z y j a z n i o n y m i
#include <i o s t r e a m . h>
3 #i n cl u d e <c o n i o . h>
5
c l a s s wektor3d
{ double x , y , z ;
164
7. Przeciążanie operatorów
7
public :
wektor3d ( double w1=0.0 , double w2=0.0 ,
9
double w3 = 0 . 0 )
{
x = w1 ;
y = w2 ;
z = w3 ;
}
11
friend i n t operator == ( wektor3d , wektor3d ) ;
friend i n t operator != ( wektor3d , wektor3d ) ;
13
} ;
15
operator == ( wektor3d v , wektor3d w)
{
i f ( ( v . x == w. x ) && ( v . y == w . y ) && ( v . z == w . z ) )
17
return 1 ;
e l s e return 0 ;
19
}
21
operator != ( wektor3d v , wektor3d w)
{
return ! ( v == w) ;
}
23
i n t main ( )
25
{
wektor3d v1 ( 1 0 , 1 0 , 2 0 ) , v2 ( 1 0 , 1 0 , 2 0 ) , v3 ( 1 0 , 2 0 , 2 0 ) ;
27
c o u t << " ␣ v1 ␣==␣ v2 ␣ : ␣ " << ( v1 == v2 ? " prawda " : " f a l s z " )
29
<< e n d l ;
c o u t << " ␣ v1 ␣==␣ v3 ␣ : ␣ " << ( v1 == v3 ? " prawda " : " f a l s z " )
31
<< e n d l ;
33
c o u t << " ␣ v1 ␣ !=␣ v2 ␣ : ␣ " << ( v1 != v2 ? " prawda " : " f a l s z " )
<< e n d l ;
35
c o u t << " ␣ v1 ␣ !=␣ v3 ␣ : ␣ " << ( v1 != v3 ? " prawda " : " f a l s z " )
<< e n d l ;
37
g e t c h ( ) ;
return 0 ;
39
}
Po uruchomieniu programu otrzymujemy następujący wynik:
v1 == v2 : prawda
v1 == v3 : f a l s z
v1 != v2 : f a l s z
v1 != v3 : prawda
W klasie wektor3d zadeklarowano dwie operatorowe funkcje zaprzyjaźnione
o nazwach operator == i operator !=:
friend i n t operator == ( wektor3d , wektor3d ) ;
friend i n t operator != ( wektor3d , wektor3d ) ;
Będą one otrzymywać po dwa argumenty typu wektor3d. Implementacja
tych funkcji ma postać:
7.7. Przeciążanie operatora przypisania ( = )
165
operator == ( wektor3d v , wektor3d w)
{
i f ( ( v . x == w. x ) && ( v . y == w . y ) && ( v . z == w . z ) )
return 1 ;
e l s e return 0 ;
}
operator != ( wektor3d v , wektor3d w)
{
return ! ( v == w) ;
}
Widzimy, że operator przeciążony może być zdefiniowany jako funkcja skła-
dowa i jako funkcja globalna (lub zaprzyjaźniona). Wobec tego musimy od-
powiedzieć na pytanie, jakie są kryteria wyboru implementacji przeciążania
operatora. Prawdę mówiąc nie ma generalnej zasady, wszystko zależy od
zastosowania przeciążonego operatora.
Jeżeli operator modyfikuje operandy to powinien być zdefinio-
wany jako funkcja składowa klasy. Przykładem są tu takie opera-
tory jak: =, +=, -=, *=, ++, itp. Jeżeli operator nie modyfikuje
swoich operandów to należy go definiować jako funkcję globalną
lub zaprzyjaźnioną. Przykładem są tu takie operatory jak: +, -,
==, &, itp.
7.7. Przeciążanie operatora przypisania ( = )
Operator przypisania jest szczególnym operatorem, ponieważ w przy-
padku, gdy nie zostanie przeciążony, jest on definiowany przez kompilator.
Tak więc, operacja przypisani jednego obiektu drugiemu jest zawsze wyko-
nalna. Ilustruje ten fakt kolejny program. W naszym przykładzie została
zaimplementowana klasa data:
c l a s s data
{
private :
i n t d z i e n ;
i n t m i e s i a c ;
i n t rok ;
public :
data ( i nt = 1 , i nt = 1 , i nt = 2004 ) ; // k o n s t r u k t o r
void pokaz ( void ) ; // f u n k c j a skladowa , p o k a z u j e d a t e
} ;
Ta klasa nie zawiera funkcji operatorowej przypisania. W funkcji głównej
main() mamy instrukcję:
d1 = d2 ;
166
7. Przeciążanie operatorów
co oznacz, że odpowiednie pola obiektu d2 są przypisane polom obiektu d1.
Ten typ przypisania nosi nazwę przypisania danych składowych (member-
wise assignment).
Listing 7.8. przypisanie bez przeciążania operatorów
1 #i n cl u d e <i o s t r e a m . h>
#include <iomanip . h>
3 #i n cl u d e <c o n i o . h>
c l a s s data
5
{ private :
i n t d z i e n ;
7
i n t m i e s i a c ;
i n t rok ;
9
public :
data ( i nt = 1 , i nt = 1 , i nt = 2004) ;
// k o n s t r u k t o r
11
void pokaz ( void ) ;