operator

Przeciażanie ˛ operatorów (odsłona druga)
Bogdan Kreczmer
ZPCiR IIAiR PWr
pokój 307 budynek C3
bogdan.kreczmer@pwr.wroc.pl
Copyright c○2005–2008 Bogdan Kreczmer ⋆
⋆ Niniejszy dokument zawiera materiały do wykładu na temat programowania obiektowego. Jest on udostępiony pod
warunkiem wykorzystania wyłacznie ˛ do własnych prywatnych potrzeb i może on być kopiowany wyłacznie ˛ w całości, razem z
niniejsza˛
strona˛
tytułowa.
˛

1
Operatory arytmetyczne, bitowe i logiczne (i nie tylko)
Indeksowanie wskaźnik [ wyrażenie ]
Wywołanie funkcji wyrażenie ( lista wyrażeń )
Przyrostkowa inkrementacja l-wartość ++
Przyrostkowa dekrementacja l-wartość - -
Równy
Nierówny
Koniunkcja bitowa
⇓
wyrażenie == wyrażenie
wyrażenie != wyrażenie
wyrażenie & wyrażenie
Przedrostkowa inkrementacja
++ l-wartość
Różnica symetryczna
wyrażenie ˆwyrażenie
Przedrostkowa dekrementacja
- - l-wartość
Alternatywa bitowa
wyrażenie | wyrażenie
Negacja bitowa
∼wyrażenie
Iloczyn logiczny
wyrażenie && wyrażenie
Negacja logiczna
! wyrażenie
Suma logiczna
wyrażenie || wyrażenie
Minus jednoargumentowy
- wyrażenie
Wyrażenie warunkowe
wyrażenie ? wyr. : wyr.
Plus jednoargumentowy
+ wyrażenie
Proste przypisanie
l-wartość = wyrażenie
Mnożenie
wyrażenie ∗ wyrażenie
Przemnóż i przypisz
l-wartość ∗= wyrażenie
Dzielenie
wyrażenie / wyrażenie
Podziel i przypisz
l-wartość /= wyrażenie
Modulo
wyrażenie % wyrażenie
Weź modulo i przypisz
l-wartość %= wyrażenie
Dodawanie
wyrażenie + wyrażenie
Dodaj i przypisz
l-wartość += wyrażenie
Odejmowanie
wyrażenie - wyrażenie
Odejmij i przypisz
l-wartość -= wyrażenie
Przesuwanie w lewo
wyrażenie >= wyr.
Mniejszy
wyrażenie < wyrażenie
Koniunkcja bitowa i przypisz
l-wartość &= wyrażenie
Mniejszy lub równy
wyrażenie wyrażenie
wyrażenie >= wyrażenie
⇓
Różnica bitowa i przypisz l-wartość ˆ= wyrażenie
Operatory zawarte w tej samej części tabeli maja˛
ten
sam priorytet.
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
2
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 ❤ ✭✭✭✭✭✭ ❤❤❤❤❤ = 0;
Z1 = Z2 = Z3 = Z4;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
2
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 ❤ ✭✭✭✭✭✭ ❤❤❤❤❤ = 0;
Z1 = Z2 = Z3 = Z4;
Operacja przypisania domyślnie realizowana jest tylko między obiektami tego samego typu. Jej
istotna˛
cecha˛
jest to, że może ona być realizowana w sposób kaskadowy (kilka przypisań złożonych
w jedna˛
instrukcję).
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
3
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator = ( LZespolona Z)
{ re = Z. re; im = Z. im; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 = Z2 = Z3 = Z4;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
3
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator = ( LZespolona Z)
{ re = Z. re; im = Z. im; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 = Z2 = Z3 = Z4;
Domyślna implementacja operacji przypisania jest znacznie bardziej efektywna niż zwykłe przepisywanie
wartości poszczególnych pól. Dlatego też jeżeli nie jest to konieczne, to nie należy reimplementować
tej operacji.
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
4
Z1 = Z2 = Z3 = Z4;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
4
Z1 = Z2 = Z3 = Z4;
Operacja przypisania jest prawostronnie łaczna
˛
Z1 = (Z2 = (Z3 = Z4));
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
4
Z1 = Z2 = Z3 = Z4;
Operacja przypisania jest prawostronnie łaczna
˛
Z1 = (Z2 = (Z3 = Z4));
⇓
Z1 = Z2 = Z3 = Z4;
// Wykonane zostaje działanie przypisania.
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
4
Z1 = Z2 = Z3 = Z4;
Operacja przypisania jest prawostronnie łaczna
˛
Z1 = (Z2 = (Z3 = Z4));
⇓
Z1 = Z2 = Z3 = Z4;
⇓
Z1 = Z2 = Z3;
// Wykonane zostaje działanie przypisania.
// Po wykonaniu przypisania zwracana jest referencja
// do obiektu po lewej stronie.
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
4
Z1 = Z2 = Z3 = Z4;
Operacja przypisania jest prawostronnie łaczna
˛
Z1 = (Z2 = (Z3 = Z4));
⇓
Z1 = Z2 = Z3 = Z4;
⇓
Z1 = Z2 = Z3;
// Wykonane zostaje działanie przypisania.
// Po wykonaniu przypisania zwracana jest referencja
// do obiektu po lewej stronie.
⇓ // itd. . . .
Z1 = Z2 = Z3;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
4
Z1 = Z2 = Z3 = Z4;
Operacja przypisania jest prawostronnie łaczna
˛
Z1 = (Z2 = (Z3 = Z4));
⇓
Z1 = Z2 = Z3 = Z4;
⇓
Z1 = Z2 = Z3;
// Wykonane zostaje działanie przypisania.
// Po wykonaniu przypisania zwracana jest referencja
// do obiektu po lewej stronie.
⇓ // itd. . . .
Z1 = Z2 = Z3;
⇓
Z1 = Z2;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
4
Z1 = Z2 = Z3 = Z4;
Operacja przypisania jest prawostronnie łaczna
˛
Z1 = (Z2 = (Z3 = Z4));
⇓
Z1 = Z2 = Z3 = Z4;
⇓
Z1 = Z2 = Z3;
// Wykonane zostaje działanie przypisania.
// Po wykonaniu przypisania zwracana jest referencja
// do obiektu po lewej stronie.
⇓ // itd. . . .
Z1 = Z2 = Z3;
⇓
Z1 = Z2;
⇓
Z1 = Z2;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
5
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
void operator = ( LZespolona Z)
{ re = Z. re; im = Z. im; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 ❤ ✭✭✭✭✭✭ ❤❤❤❤❤ = Z2 ❤ ✭✭✭✭✭✭ ❤❤❤❤❤
= Z3 = Z4;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
5
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
void operator = ( LZespolona Z)
{ re = Z. re; im = Z. im; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 ❤ ✭✭✭✭✭✭ ❤❤❤❤❤ = Z2 ❤ ✭✭✭✭✭✭ ❤❤❤❤❤
= Z3 = Z4;
Zaniechanie zwracania referencji lub zwrócenie referencji stałej w definicji przeciażenia ˛ operatora
przypisania uniemożliwia kaskadowa˛
realizację tej operacji.
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
6
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator = (float Arg)
{ re = im = Arg; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 = 0;
Z1 = Z2 = Z3 = Z4 = 0;
Przeciażanie ˛ operatorów (odsłona druga)

Operator przypisania
6
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator = (float Arg)
{ re = im = Arg; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 = 0;
Z1 = Z2 = Z3 = Z4 = 0;
Przeciażenie ˛ operatora przypisania dla argumentu odmiennego typu niż klasa, w której to przeciażenie
˛ jest definiowane, nie wyklucza możliwości korzystania z domyślnej implementacji operacji
przypisania.
Przeciażanie ˛ operatorów (odsłona druga)

Operator dodania i przypisania
7
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator += ( const LZespolona& Z)
{ re += Z. re; im += Z. im; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 += Z2 += Z3 += Z4;
Przeciażanie ˛ operatorów (odsłona druga)

Operator dodania i przypisania
7
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator += ( const LZespolona& Z)
{ re += Z. re; im += Z. im; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3, Z4;
}
Z1 += Z2 += Z3 += Z4;
Operator dodania i przypisania jest również operatorem prawostronnie łacznym. ˛ Przekazanie argumentu
operacji przez referencję zapobiega tworzeniu kopii tego obiektu. Stałość referencji pozwala
użyć jako drugiego argumentu operacji zarówno obiektów stałych, jak też modyfikowalnych.
Przeciażanie ˛ operatorów (odsłona druga)

8
Operator dodania i przypisania – warianty implementacji przeciażeń
˛
class LZespolona { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator += ( const LZespolona & Z )
{ re += Z. re; im += Z. im; return ∗this ; }
LZespolona operator + ( LZespolona Z2 ) const { return Z2 += ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3;
}
Z1 = Z2 + Z3;
Przeciażanie ˛ operatorów (odsłona druga)

8
Operator dodania i przypisania – warianty implementacji przeciażeń
˛
class LZespolona { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator += ( const LZespolona & Z )
{ re += Z. re; im += Z. im; return ∗this ; }
LZespolona operator + ( LZespolona Z2 ) const { return Z2 += ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3;
}
Z1 = Z2 + Z3;
Przeciażaj ˛ ac ˛ wcześniej operator dodania i przypisania można w prosty i efektywny sposób zapisać
definicję operatora dodawania. Operator ten powinien zwracać wartość, a nie referencję.
Przeciażanie ˛ operatorów (odsłona druga)

9
Operator odejmowania i przypisania – warianty implementacji przeciażeń
˛
class LZespolona { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator –= ( const LZespolona & Z )
{ re –= Z. re; im –= Z. im; return ∗this ; }
LZespolona operator – ( const LZespolona & Z2 ) const
{ return LZespolona(∗this ) –= Z2; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3;
}
Z1 = Z2 – Z3;
Przeciażanie ˛ operatorów (odsłona druga)

9
Operator odejmowania i przypisania – warianty implementacji przeciażeń
˛
class LZespolona { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator –= ( const LZespolona & Z )
{ re –= Z. re; im –= Z. im; return ∗this ; }
LZespolona operator – ( const LZespolona & Z2 ) const
{ return LZespolona(∗this ) –= Z2; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1, Z2, Z3;
}
Z1 = Z2 – Z3;
W przypadku operacji nieprzemiennych należy zastosować bardziej ogólny schemat definiowania
przeciażenia ˛ operatora, tak jak to ma miejsce dla operacji odejmowania.
Przeciażanie ˛ operatorów (odsłona druga)

10
Operator mnożenia – warianty implementacji przeciażeń
˛
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona(float r, float i) { re = r; im = i; }
LZespolona operator ∗ (const LZespolona & Z2) const;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona LZespolona::operator ∗ (const LZespolona & Z2) const
{
return LZespolona( re∗Z2. re – im∗Z2. im, re∗Z2. im + im∗Z2. re );
}
int main( )
{
LZespolona
Z1(0,0), Z2(2,1), Z3(9,3);
}
Z1 = Z2 ∗ Z3;
Przeciażanie ˛ operatorów (odsłona druga)

10
Operator mnożenia – warianty implementacji przeciażeń
˛
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona(float r, float i) { re = r; im = i; }
LZespolona operator ∗ (const LZespolona & Z2) const;
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
LZespolona LZespolona::operator ∗ (const LZespolona & Z2) const
{
return LZespolona( re∗Z2. re – im∗Z2. im, re∗Z2. im + im∗Z2. re );
}
int main( )
{
LZespolona
Z1(0,0), Z2(2,1), Z3(9,3);
}
Z1 = Z2 ∗ Z3;
Wykorzystanie konstruktora może ułatwić zapis procedury tworzenia końcowego wyniku, gdyż ła-
˛
czymy w ten sposób konstrukcję obiektu i jego inicjalizację. W takim przypadku drugi argument
powinien być przekazany przez stała˛
referencję, aby uniknać ˛ zbędnego kopiowania.
Przeciażanie ˛ operatorów (odsłona druga)

Przed- i przyrostkowe operatory inkrementacji
11
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator ++ ( ) { ++ re; ++ im; return ∗this ; } // ++Z
LZespolona operator ++ ( int )
{ LZespolona Z(∗this ); ++∗this ; return Z; } // Z++
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1;
}
Z1. re = Z1. im = 2;
Z1++. re
❤❤❤❤❤❤
✭✭✭✭✭✭
+= 1;
Przeciażanie ˛ operatorów (odsłona druga)

Przed- i przyrostkowe operatory inkrementacji
11
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator ++ ( ) { ++ re; ++ im; return ∗this ; } // ++Z
LZespolona operator ++ ( int )
{ LZespolona Z(∗this ); ++∗this ; return Z; } // Z++
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1;
}
Z1. re = Z1. im = 2;
Z1++. re
❤❤❤❤❤❤
✭✭✭✭✭✭
+= 1;
Rozróżnienie operatora przed- od przyrostkowego jest realizowane przez wprowadzenie parametru
typu int. Wskazane jest, aby przeciażenie ˛ operatora przedrostkowego zwracało referencję do
obiektu, zaś przyrostkowego kopię. Jednak nie jest to obowiazkowe.
˛
Przeciażanie ˛ operatorów (odsłona druga)

Operatory – i +
12
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator + ( ) const { return ∗this ; }
LZespolona & operator – ( ) { re = – re; im = – im; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1;
}
Z1. re = Z1. im = 2;
(–Z1). re += 1;
Przeciażanie ˛ operatorów (odsłona druga)

Operatory – i +
12
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float re, im;
LZespolona & operator + ( ) const { return ∗this ; }
LZespolona & operator – ( ) { re = – re; im = – im; return ∗this ; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z1;
}
Z1. re = Z1. im = 2;
(–Z1). re += 1;
Implementacja przeciażeń ˛ operatorów powinna, o ile to jest tylko możliwe, być zgodna z intuicyjnym
rozumieniem operatorów. Przeciażenia, ˛ które nie zmieniaja˛
stanu obiektu, powinny być definiowane
jako metody “stałe”.
Przeciażanie ˛ operatorów (odsłona druga)

Problem z priorytetami
13
class Wektor3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float x, y, z;
Wektor3f operator ∗ (const Wektor3f & W2) const; // Iloczyn wektorowy
float operator & (const Wektor3f & W2) const; // Iloczyn skalarny
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
Wektor2f V1, V2;
}
if (
V1
❤❤❤❤❤❤❤❤❤
✭✭✭✭✭✭✭✭✭
& V2 > 0 ) { . . . } // Zwyczajowy zapis: V 1 ·V 2 > 0
if ( (V1 & V2) > 0 ) { . . . }
Przeciażanie ˛ operatorów (odsłona druga)

Problem z priorytetami
13
class Wektor3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float x, y, z;
Wektor3f operator ∗ (const Wektor3f & W2) const; // Iloczyn wektorowy
float operator & (const Wektor3f & W2) const; // Iloczyn skalarny
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
Wektor2f V1, V2;
}
if (
V1
❤❤❤❤❤❤❤❤❤
✭✭✭✭✭✭✭✭✭
& V2 > 0 ) { . . . } // Zwyczajowy zapis: V 1 ·V 2 > 0
if ( (V1 & V2) > 0 ) { . . . }
Dobór operatorów do realizacji poszczególnych operacji powinien być możliwie zbliżony do ich pierwotnego
znaczenia. Jednak z drugiej strony wzajemne priorytety operatorów powinny odpowiadać
priorytetom implementowanych operacji. Nie zawsze te wymagania daja˛
się pogodzić.
Przeciażanie ˛ operatorów (odsłona druga)

Operator indeksujacy
˛
class Wektor3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float x, y, z;
14
float operator [ ] ( unsigned int ind ) const
{ return ind ? ind == 1 ? y : z : x; }
float & operator [ ] ( unsigned int ind )
{ return ind ? ind == 1 ? y : z : x; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Wektor2f V1, V2;
}
V1.x = V2[2];
V1[2] = V2.z;
Przeciażanie ˛ operatorów (odsłona druga)

Operator indeksujacy
˛
class Wektor3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
float x, y, z;
14
float operator [ ] ( unsigned int ind ) const
{ return ind ? ind == 1 ? y : z : x; }
float & operator [ ] ( unsigned int ind )
{ return ind ? ind == 1 ? y : z : x; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Wektor2f V1, V2;
}
V1.x = V2[2];
V1[2] = V2.z;
Przeciażenie ˛ operator indeksujacego ˛ pozwala na dostęp do tych samych struktur na dwa sposoby.
Pierwszy z nich pozwala odwołać do konkretnych pól po nazwie, drugi zaś pozwala widzieć cała˛
strukturę jako tablicę. Podwójne przeciażenie ˛ pozwala na realizację zarówno odczytu jak też zapisu.
Przedstawiona implementacja przeciażeń ˛ nie zapewnia pełnej kontroli zakresu.
Przeciażanie ˛ operatorów (odsłona druga)

Operator indeksujacy
˛
15
class Wektor3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
union { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[3];
struct { float x, y, z; };
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float operator [ ] ( unsigned int ind ) const { return Tab[ ind ]; }
float & operator [ ] ( unsigned int ind ) { return Tab[ ind ]; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Wektor2f V1, V2;
}
V1.x = V2[2];
V1[2] = V2.z;
Przeciażanie ˛ operatorów (odsłona druga)

Operator indeksujacy
˛
15
class Wektor3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
union { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[3];
struct { float x, y, z; };
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float operator [ ] ( unsigned int ind ) const { return Tab[ ind ]; }
float & operator [ ] ( unsigned int ind ) { return Tab[ ind ]; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Wektor2f V1, V2;
}
V1.x = V2[2];
V1[2] = V2.z;
Wykorzystanie w definicji nienazwanej unii zapewnia realizację znacznie bardziej efektywnego dostępu
na różne sposoby do tego samego obszaru pamięci. (Niestety niedopuszczalne w ANSI C++ :(
Przeciażanie ˛ operatorów (odsłona druga)

Operator indeksujacy
˛
16
class Wektor3f { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
union { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[3];
struct { float x, y, z; };
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
union { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
struct { float x, y, z; };
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float operator [ ] ( unsigned int ind ) const { return Tab[ ind ]; }
float & operator [ ] ( unsigned int ind ) { return Tab[ ind ]; }
float Norma( ) const { return sqrt( x∗ x + y∗ y + z∗ z); }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Przeciażanie ˛ operatorów (odsłona druga)

Operator indeksujacy
˛
16
class Wektor3f { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
union { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[3];
struct { float x, y, z; };
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
union { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
struct { float x, y, z; };
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float operator [ ] ( unsigned int ind ) const { return Tab[ ind ]; }
float & operator [ ] ( unsigned int ind ) { return Tab[ ind ]; }
float Norma( ) const { return sqrt( x∗ x + y∗ y + z∗ z); }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Unie nienazwane pozwalaja˛
odwoływać się do tego samego obszaru pamięci nie tylko w różny sposób,
ale również pozwalaja˛
tworzyć konstrukcje definiujace ˛ dostępność ze względu na zadany sposób
odwołania do pamięci. Nie należy jednak nadużywać tego mechanizmu do tworzenia wielu
synonimów nazw pól.
Przeciażanie ˛ operatorów (odsłona druga)

Operator funkcyjny
17
class Macierz3x3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[3][3];
public :
float operator ( ) (unsigned int i, unsigned int j) const{ return Tab[ i ][ j ]; }
float& operator ( ) (unsigned int i, unsigned int j) { return Tab[ i ][ j ]; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Macierz3x3f M;
}
M(1,2) = 5;
M(1,1) = M(1,2);
Przeciażanie ˛ operatorów (odsłona druga)

Operator funkcyjny
17
class Macierz3x3f { //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[3][3];
public :
float operator ( ) (unsigned int i, unsigned int j) const{ return Tab[ i ][ j ]; }
float& operator ( ) (unsigned int i, unsigned int j) { return Tab[ i ][ j ]; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Macierz3x3f M;
}
M(1,2) = 5;
M(1,1) = M(1,2);
Przeciażenie ˛ operatorów wywołania funkcji pozwala na organizację wygodnego dostępu do wewnętrznych
struktur tablicowych.
Przeciażanie ˛ operatorów (odsłona druga)

Pytania i ćwiczenia
18
1. Dany jest fragment kodu:
class ProstaKlasa {
int Pole;
public:
void Zmien(int Wart) { Pole = Wart; }
};
int main()
{
ProstaKlasa const Ob;
ProstaKlasa &Ref = Ob;
. . .
A. Czy powyżej w poprawny sposób utworzona została referencja do obiektu Ob?
B. Jeżeli nie, to jak należy to zapisać aby operacja była poprawna (nie zmieniajac
˛
deklaracji referencji Ref)?
C. Jeżeli tak, to jak należy to zapisać aby uniemożliwić taka˛
operację?
D. Czy po utworzeniu referencji Ref będzie się można poprzez nia˛
odwołać do metody
Zmien?
Przeciażanie ˛ operatorów (odsłona druga)

Pytania i problemy
19
2. Dana jest definicja klasy LZespolona:
class LZespolona {
public :
float re, im;
LZespolona operator = ( LZespolona Z)
{ re = Z. re; im = Z. im; return ∗this ; }
};
Niech będa˛
dane zmienne: LZespolona Z1, Z2, Z3. Czy dwie poniższe operacje daja˛
taki
sam wynik?
Z1 = Z2 = Z3;
(Z1 = Z2) = Z3;
Jeżeli tak, to jaki zachodzi zwiazek ˛ między wartościami zmiennych? Jeżeli natomiast nie, to
co należy zrobić, aby wynik był taki sam?
3. Dana jest definicja klasy:
class LZespolona {
public :
float re, im;
LZespolona & operator ++ (int) { ++ re; ++ im; return ∗this ; }
};
Czy działanie przedstawione poniżej jest prawidłowo zapisane (w sensie składni)?
LZespolona Z1; Z. re = Z. im = 2; ++Z. re += 1;
Jeżeli tak, to jaki jest wynik działania? Jeżeli nie, to co należy zrobić, aby było ono poprawne.
Przeciażanie ˛ operatorów (odsłona druga)