Programo
w
anie
obiekto
w
e
W
ykª
ad
3.
K
onstrukto
ry
(uzup
eªnienie),
zas
»y ia
obiektó
w,
op
erato
ry
,
k
onw
ersje
t
yp
ó
w
Programo
w
anie
obiekto
w
e
W
ykª
ad
3.
K
onstrukto
ry
(uzup
eªnienie),
zas
»y ia
obiektó
w,
op
erato
ry
,
k
onw
ersje
t
yp
ó
w
K
onstrukto
r
p
rzyp
omnienie
◮
K
onstrukto
r
to
sp
e jalna
meto
da
wyw
oªyw
ana
(automat
y znie
lub
ja
wnie)
w
momen ie
t
w
o
rzenia
obiektu.
◮
Nazw
a
k
onstrukto
ra
jest
tak
a
jak
nazw
a
klasy
.
◮
K
onstrukto
r
nie
zwra a
w
a
rto± i,
mo»e
mie¢
a
rgument
y
,
mo»e
b
y¢
p
rzeª
ado
w
any
.
K
onstrukto
r
p
eªna
skª
adnia
nazw
a(a
rgument
y)
:
lista_ini jaliza yjna
{
instruk
je
}
Lista
ini jaliza yjna
za
wiera
sekw
en j
ini jalizato
ro
w.
Ini jalizato
rem
mo»e
b
y¢:
◮
atrybut(wyra»enie)
zaini jalizo
w
anie
atrybutu
(niestat
y znego)
w
a
rto± i¡
wyra»enia.
◮
atrybut(lista_pa
rametró
w_k
onstrukto
ra)
zaini jalizo
w
anie
atrybutu
(niestat
y znego)
za
p
omo
¡
jego
k
onstrukto
ra
◮
wyw
oª
anie
k
onstrukto
ra
nadklasy
K
onstrukto
r
ini jaliza ja
staª
ej
lass
A
{
onst
int
stala;
//
tu
nie
mo»na
zaini jalizowa¢
staªej
A()
:
stala(0)
//
tylko
tu
mo»na
zaini jalizowa¢
staª¡
{
//
tu
nie
mo»na
zaini jalizowa¢
staªej
}
};
K
onstrukto
r
ini jaliza ja
atrybutu
nie
b
d¡ ego
staª
¡
lass
A
{
int
a,b, ;
//
tu
nie
mo»na
zaini jalizowa¢
A()
:
a(1), (0)
//
mo»na
tu
{
b=1;
//
albo
tu
}
}
K
onstrukto
r
ini jaliza ja
atrybutu
b
d¡ ego
referen j¡
lass
A
{
B&
b;
A(B&
bref)
:
b(bref)
{
//
tu
ju»
nie
mo»na
manipulowa¢
warto± i¡
b
}
};
K
onstrukto
r
k
onstruk
ja
z± i
dziedzi zonej
obiektu
lass
A
{
int
a;
A(int
i)
a(i)
:
{
}
//
konstruktor
w
klasie
A
}
lass
B
:
publi
A
//
B
jest
podklas¡
A
{
int
b;
B(int
i,
int
j)
:
A(i),
//
wywoªanie
konstruktora
nadklasy
b(j)
//
ini jaliza ja
niedziedzi zone
go
atrybutu
b
{
}
};
K
onstrukto
r
k
opiuj¡ y
◮
Jest
to
sp
e jalny
k
onstrukto
r,
k
onstuuj¡ y
obiekt
na
p
o
dsta
wie
p
o
danego
jak
o
a
rgument
wzo
r a.
◮
Jego
jedyny
a
rgument
jest
t
ypu
referena ja
do
obiektu
tej
samej
klasy
.
◮
K
onstrukto
r
k
opiuj¡ y
zazwy zaj
nie
ma
p
otrzeb
y
dok
onyw
a¢
zmian
w
e
wzo
r u,
dlatego
zwykle
u»yw
a
si
referen ji
do
obiektu
staª
ego.
lass
K
{
K(K&
k)
{...}
//
lub
K( onst
K&
k)
{...}
}
K
onstrukto
r
k
opiuj¡ y
p
rzykª
ad
lass
Osoba
{
har*
imie;
Osoba( onst
Osoba&
o)
{
imie
=
new
har[strlen(o.imie)+1℄;
str py(imie,
o.imie);
}
};
W
p
o
wy»szym
p
rzykª
adzie
atrybut
imie
w
no
wym
obiek
ie
p
o
winien
wsk
azyw
a¢
na
wª
asn¡
k
opi
imienia.
Automat
y znie
wygenero
w
any
k
onstrukto
r
k
opiuj¡ y
sk
opio
w
aªb
y
wsk
a¹nik,
o
mogª
ob
y
mie¢
niep
o»¡dane
skutki.
K
onstrukto
r
k
opiuj¡ y
k
onstrukto
r
k
opiuj¡ y
genero
w
any
automat
y znie
◮
Je±li
nie
zde niujemy
k
onstrukto
ra
k
opiuj¡ ego
genero
w
any
jest
on
automat
y znie.
◮
Automat
y znie
wygenero
w
any
k
onstrukto
r
k
opiuj¡ y
,
k
opiuje
obiekt
skª
adnik
p
o
skª
adniku,
z
wyk
o
rzystaniem
-
tam
gdzie
mamy
do
zynienie
z
obiektami
-
k
onstrukto
ró
w
k
opiuj¡ y h
z
o
dp
o
wiedni h
klas.
◮
W
wikszo± i
p
rzypadk
o
w
taki
k
onstrukto
r
k
opiuj¡ y
wysta
r za.
K
onstrukto
r
k
opiuj¡ y
wyw
oª
anie
ja
wne
Osoba
o,o1;
//
o
jest
obiektem
klasy
Osoba
...
o1
=
Osoba(o);
//
o1
ma
by¢
kopi¡
obiektu
o
K
onstrukto
r
k
opiuj¡ y
wyw
oª
anie
nieja
wne
K
onstrukto
r
k
opiuj¡ y
jest
nieja
wnie
wyw
oªyw
any
w
dw
ó
h
p
rzypadk
a h:
◮
kiedy
obiekt
jest
p
rzek
azyw
any
jak
o
pa
rametr
funk
ji/meto
dy
p
rzez
w
a
rto±¢
◮
kiedy
funk
ja/meto
da
zwra a
jak
o
w
a
rto±¢
obiekt
lass
Osoba
{
...
Osoba
sklonuj(Osoba
o)
//
przekazanie
obiektu
przez
warto±¢,
//
do
metody
trafi
kopia
argumentu
{
Osoba
o1
=
Osoba(o);
return
o1;
//
zwra ana
jest
kopia
obiektu
lokalnego
o1
}
...
}
K
onstrukto
r
k
onstrukto
r
domniemany
◮
K
onstrukto
r
domniemany
to
k
onstrukto
r,
któ
ry
mo»na
uru homi¢
b
ez
a
rgumentó
w
(mo»e
to
b
y¢
k
onstrukto
r
z
a
rgumentami
domy±lnymi).
◮
Je±li
nie
zde niujemy
»adnego
k
onstrukto
ra
dla
klasy
to
ma
ona
k
onstrukto
r
domniemany
wygenero
w
any
automat
y znie.
◮
Je±li
zde niujemy
k
onstrukto
r(y)
i
nie
b
dzie
w±ró
d
ni h
takiego,
któ
ry
mo»na
uru homi¢
b
ez
a
rgumentó
w,
to
klasa
nie
ma
k
onstrukto
ra
domniemanego.
T
rzeba
pamita¢,
»e
w
p
ewny h
sytua ja h
b
rak
k
onstrukto
ra
domniemanego
p
o
w
o
duje
bª
¡d.
K
onstrukto
r
k
olejno±¢
wyk
onyw
ania
dziaª
a«
1.
uru homienie
k
onstrukto
ra
nadklasy
(je±li
klasa
jest
klas¡
p
o
ho
dn¡)
◮
je±li
k
onstrukto
ra
ndklasy
nie
wyminili±my
na
li± ie
ini jaliza yjnej
uru hamiany
jest
k
onstrukto
r
domniemany
(b
eza
rgumento
wy)
2.
uru homienie
k
onstrukto
ró
w
obiektó
w
skª
ado
wy h
◮
obiekt
y
skª
ado
w
e
k
onstruo
w
ane
s¡
zgo
dnie
z
za
w
a
rto± i¡
list
y
ini jaliza yjnej
◮
je±li
na
li± ie
ini jaliza yjnej
nie
wsk
azali±my
k
onstrukto
ra
dla
jakiego±
obiektu
skª
ado
w
ego,
uru hamiany
jest
jego
k
onstrukto
r
domniemany
(b
eza
rgumento
wy)
3.
wyk
onanie
p
ozostaªy h
zynno± i
zde nio
w
any h
w
iele
k
onstrukto
ra
Czas
»y ia
obiektu
T
w
o
rzenie
obiektó
w
automat
y zny h
Obiekt
y
automat
y zne
maj¡
zak
es
bloku,
istniej¡
o
d
momentu
dekla
ra ji
do
k
o« a
bloku,
w
któ
rym
zostaªy
zadekla
ro
w
ane.
lass
A
//
jaka±
klasa
{
...
A()
{}
//
jej
konstruktor
bezargumentowy
A(int
n)
{
...
}
//
i
jej
konstruktor
z
argumentem
};
int
main()
{
...
{
A
a;
//
deklara ja
zm.
z
wywoªaniem
konstruktora
bezargumentowego
A
b(5);
//
deklara ja
zm.
z
wywoªaniem
konstruktora
z
argumentem
...
}
//tu
ko« zy
si
zakres
(i
»ywot)
a
i
b
...
}
Czas
»y ia
obiektu
T
w
o
rzenie
obiektó
w
globalny h
Obiekt
y
globalne
maj¡
zakres
pliku,
istniej¡
p
rzez
aªy
zas
wyk
onyw
ania
p
rogramu.
S¡
t
w
o
rzone
p
rzed
rozp
o
z iem
wyk
onyw
ania
funk
ji
main,
k
o« z¡
»yw
ot
p
o
jej
zak
o« zeniu.
lass
A
//
jaka±
klasa
{
...
A()
{}
//
jej
konstruktor
bezargumentowy
A(int
n)
{
...
}
//
i
jej
konstruktor
z
argumentem
};
A
a;
int
main()
{
...
}
Czas
»y ia
obiektó
w
Dynami zne
t
w
o
rzenie
obiektó
w
Obiekt
dynami zny
istniej¡
o
d
momentu
jego
ut
w
o
rzenia
za
p
omo
¡
op
erato
ra
new
do
momentu
jego
znisz zenia
op
erato
rem
delete.
Jest
dostpny
je±li
istnieje
i
jest
dostpna
jak
a±
zmienna
p
rze ho
wyj¡ a
wsk
a¹nik
do
niego.
lass
A
//
jaka±
klasa
{
...
A()
{}
//
jej
konstruktor
bezargumentowy
A(int
n)
{
...
}
//
i
jej
konstruktor
z
argumentem
...
};
int
main()
{
A*
a
=
new
A;
//
new
A
przydziela
pami¢
na
obiekt
klasy
A
//
i
zwra a
wska¹nik
do
niego,
obiekt
jest
//
tworzony
przez
konstruktor
bezargumentowy
B*
b
=
new
A(5);
//
j.w.
ale
zadzaiªa
konstruktor
z
argumentem
...
delete
a;
//
utworzony
dynami znie
obiekt
TRZEBA
ZNISZCZY
delete
b;
//
kiedy
jest
ju»
niepotrzebny
}
Czas
»y ia
obiektó
w
T
w
o
rzenie
obiektó
w
hwilo
wy h
◮
K
onstrukto
r
mo»na
wyw
oª
a¢
ja
wnie
tak,
jak
b
y
b
yª
zwykª
¡
funk
j¡
zwra aj¡ ¡
obiekt.
Obiekt
taki
jest
' hwilo
wy'
(=
istniej¡ y
t
ylk
o
w
ob
rbie
wyra»enia
w
któ
rym
go
ut
w
o
rzono).
◮
U»y ie
obiektó
w
hwilo
wy h
p
rzyp
omina
u»y ie
staªy h
dosª
o
wny h
(literaª
ó
w),
jak
1
3.5
'A'
"Ala
ma
k
ota"
Czas
»y ia
obiektó
w
T
w
o
rzenie
obiektó
w
hwilo
wy h:
p
rzykª
ad
lass
A
//
jaka±
klasa
{
...
A()
{
}
//
jej
konstruktor
bezargumentowy
A(int
n)
{
...
}
//
i
jej
konstruktor
z
argumentem
A
f()
//
jaka±
metoda
zwra aj¡ a
obiekt
klasy
A
{
...
return
A(0);
//
jawne
wywoªanie
konstruktora
tworzy
obiekt
//
hwilowy,
który
jest
zwra any
przez
metod
}
};
int
main()
{
A
a
=
A();
//
obiekt
hwilowy
zwró ony
przez
konstruktor
jest
//
przypisywany
zmiennej
a;
A
b;
b
=
A(3);
//
j.w.
(zmiennej
b)
a
=
f();
//
obiekt
hwilowy
zwró ony
przez
f()
jest
przypisywany
//
zmiennej
a
}
Op
erato
ry
◮
W
jzyku
C++
mamy
mo»liw
o±¢
de nio
w
ania
op
erato
ró
w.
◮
T
e hni znie,
p
olega
to
na
p
rzeª
ado
w
aniu
istniej¡ y h
op
erato
ró
w,
zde nio
w
aniu
i h
dziaª
ania
dla
inny h
t
yp
ó
w
a
rgumentó
w.
◮
Op
erato
ry
mo»na
de nio
w
a¢
jak
o
meto
dy
klasy
lub
jak
o
funk
je
na
zewn¡trz
klasy
.
De ni je
op
erato
ró
w
maj¡
p
osta¢
tak
¡
sam¡
jak
de ni je
meto
d/funk
ji,
z
t¡
ró»ni ¡,
»e
w
mies u
nazwy
meto
dy/funk
ji
piszemy:
operatorX
gdzie
X
jest
jednym
z
op
erato
ró
w:
+
-
*
/
%
^
&
|
~
!
=
<
>
+=
-=
*=
/=
%=
^=
&=
|=
<<
=
<<=
==
!=
<=
>=
&&
||
++
,
->*
->
new
delete
()
[℄
◮
Prio
rytet
y
op
erato
ró
w
nie
mog¡
b
y¢
zmienione.
Op
erato
ry
p
rzykª
ad:
de ni ja
op
erato
ra
dwua
rgumento
w
ego
lass
Zespolona
{
publi :
float
re,
im;
Zespolona()
:
re(0),
im(0)
{
}
Zespolona(float
r,
float
i)
:
re(r),
im(i)
{
}
//defini ja
operatora
w
posta i
metody:
Zespolona
operator+(Zespolona
z)
{
return
Zespolona(re+z.re,
im+z.im);
}
};
//
defini ja
operatora
w
posta i
funk ji
Zespolona
operator-(Zespolona
z1,
Zespolona
z2)
{
return
Zespolona(z1.re+z2.re,
z1.im+z2.im);
}
int
main()
{
Zespolona
a(1,2),
b(3,0),
,
d
=
a
+
b;
d
=
-
Zespolona(1,0);
}
Op
erato
ry
de ni ja
op
erato
ra
jednoa
rgumento
w
ego
p
re kso
w
ego
lass
Zespolona
{
...
Zespolona
operator-()
{
return
Zespolona(-re,im);
}
};
Zespolona
operator-(Zespolona
z)
{
return
Zespolona(-z.re,im);
}
Op
erato
ry
op
erato
r
p
rzypisania
Op
erato
r
p
rzypisania
ma
status
sz zególny
.
Jest
jedyn¡
niedziedzi zon¡
meto
d¡
klasy
(p
oza
k
onstrukto
rami
i
destrukto
rem).
lass
K
{
K&
operator=(K&
k)
{...}
//
lub
K&
operator=( onst
K&
k)
{...}
}
Czsto
stoso
w
an¡
p
rakt
yk
¡
jest
zab
ezpie zanie
a
rgumentu
op
erato
ra
p
rzypisania
p
rzed
mo»liw
o± i¡
mo
dy k
a ji
ZA
WSZE.
(Niek
onsekw
entne
stoso
w
anie
onst
p
ro
w
adzi
do
kª
op
otó
w).
Op
erato
ry
op
erato
r
p
rzypisania
genero
w
any
automat
y znie
◮
Je±li
nie
zde niujemy
op
erato
ra
p
rzypisania
genero
w
any
jest
on
automat
y znie.
◮
Automat
y znie
wygenero
w
any
op
erato
r
p
rzypisania,
dok
onuje
p
rzypisania
skª
adnik
p
o
skª
adniku,
z
wyk
o
rzystaniem
-
tam
gdzie
mamy
do
zynienie
z
obiektami
-
op
erato
ró
w
p
rzypisania
z
o
dp
o
wiedni h
klas.
◮
W
wikszo± i
p
rzypadk
o
w
taki
op
erato
r
p
rzypisania
wysta
r za.
Op
erato
ry
op
erato
r
p
rzypisania:
p
rzykª
ad
lass
Osoba
{
...
Osoba&
operator=( onst
Osoba&
o)
{
if(imie!=NULL)
//
je±li
obiekt
ma
imie
delete[℄
o.imie;
//
znisz z
stare
imie
(zwolnij
pami¢)
imie
=
new
har[strlen(o.imie)+1℄;
//
zdob¡d¹
pami¢
na
nowe
imie
str py(imie,
o.imie);
//
i
przekopiuj
je
tam
}
...
publi :
har*
imie;
}
Op
erato
ry
p
rzeª
ado
w
anie
op
erato
ra
<<
dla
stumienia
wyj± io
w
ego
#in lude<iostream>
using
namespa e
std;
lass
Zespolona
{
publi :
Zespolona(double
r,
double
i)
:
_re(r),
_im(i)
{}
double
re()
{
return
_re;
}
double
im()
{
return
_im;
}
private:
double
_re,_im;
};
ostream&
operator<<(ostream&
os,
Zespolona
z)
{
os
<<
"("
<<
z.re()
<<
","
<<
z.im()
<<
")";
return
os;
}
int
main()
{
Zespolona
z(1,
2.5);
out
<<
z;
//
na
wyj± iu:
(1,2.5)
}
K
onw
ersje
t
yp
ó
w
◮
W
jzyku
C++
p
rogramista
mo»e
zde nio
w
a¢
reguªy
k
onw
ersji
t
yp
ó
w
jakie
maj¡
b
y¢
stoso
w
ane
dla
obiektó
w
klas
p
rzez
niego
de nio
w
any h.
◮
Zde nio
w
ane
w
ten
sp
osób
k
onw
ersje
mog¡
b
y¢
u»yte
ja
wnie,
z
wyk
o
rzystaniem
op
erato
ra
k
onw
ersji
(t
yp).
◮
S¡
te»
u»yw
ane
nieja
wnie
p
rzez
k
ompilato
r
w
trak
ie
dopaso
wyw
ania
wyw
oª
ania
funk
ji/meto
dy
,
stano
wi¡
uzup
eªnienie
k
onw
ersji
p
rede nio
w
any h.
K
onw
ersje
t
yp
ó
w
k
onw
ersja
zde nio
w
ana
p
rzez
k
onstrukto
r
K
onstrukto
r
z
jednym
a
rgumentem
okre±la
k
onw
ersj
z
t
ypu
tego
a
rgumentu
na
t
yp
sw
ojej
klasy
.
lass
Zespolona
{
...
Zespolona(double
f)
re(f),
im(0)
:
{
}
//
konwersja
z
double
na
Zespolona
...
private:
double
re,im;
};
int
main()
{
Zespolona
z1,z2,z3;
z1
=
Zespolona(2.5);
//
zwykªe
wywoªanie
konstruktora
z2
=
(Zespolona)0;
//
jawnie
wywoªana
konwersja
z3
=
5.0;
//
niejawna
konwersja
z
double
na
Zespolona
z4
=
5;
//
int
->
double
->
Zespolona
}
K
onw
ersje
t
yp
ó
w
k
onw
ersja
zde nio
w
ana
p
rzez
op
erato
r
k
onw
ersji
Op
erato
r
b
eza
rgumento
wy
T(),
któ
rego
nazw
a
T
jest
nazw
¡
t
ypu
defninuje
k
onw
ersje
z
t
ypu
sw
ojej
klasy
na
t
yp
T.
lass
Zespolona
{
...
operator
double()
{
return
re;
}
//
konwersja
z
Zespolona
na
double
...
private:
float
re,im;
};
int
main()
{
Zespolona
z(1,-1.5);
double
x
=
(double)z;
//
jawna
konwersja
double
y
=
z;
//
niejawna
konwersja
z
Zespolona
na
double
out
<<
z;
//
niejawna
konwersja
z
Zespolona
na
double
}
K
onw
ersje
t
yp
ó
w
UW
A
GA!
Przy
de nio
w
aniu
k
onw
ersji
trzeba
za ho
w
a¢
ostro»no±¢:
je±li
k
omiplato
r
nap
otk
a
niejednozna zno±¢
(b
dzie
mógª
dok
ona¢
k
onw
ersji
na
wi ej
ni»
jeden
sp
osób)
zgª
osi
bª
¡d.
lass
Zespolona
{
...
operator
double()
{
return
re;
}
//
konwersja
z
Zespolona
na
double
operator
int()
{
return
(int)re;
}
//
konwersja
z
Zespolona
na
int
...
private:
float
re,im;
};
int
main()
{
Zespolona
z(1,-1.5);
double
x
=
(double)z;
//
jawna
konwersja
double
y
=
z;
//
niejawna
konwersja
z
Zespolona
na
double
out
<<
z;
//
bª¡d!
Zespolona->double
zy
Zespolona->int
?
}