Tipp: a diák között lépkedni a J és K billentyúkkel lehet. Szöveges kereséshez ctrl-F használható.
Letöltés
Programozás alapjai II.
(9. ea) C++
többszörös öröklés, cast, perzisztencia, kivételek
Szeberényi Imre, Somogyi Péter
BME IIT
<szebi@iit.bme.hu>
MŰE GYET E M 1 782
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
-1 -
Öröklés ism.
• Egy osztályból olyan újabb osztályokat származtatunk,
amelyek rendelkeznek az eredeti osztályban már definiált
tulajdonságokkal, viselkedéssel.
• Analitikus - Korlátozó √
• Egyszeres - Többszörös
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
-2 -
Többszörös öröklés
• Ha két osztály merőben különbözik, de mindkettőben
valamit meg kell valósítani a másik számára.
• Az új osztálynak többféle arcot kell mutatnia
(mutatókonverzió).
• Sokszor kiváltható barát függvényekkel, de nem a legjobb
megoldás.
• Objektum és a környezet (pl. grafikus) kapcsolata.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
-3 -
Többszörös öröklés/2
• Két vagy több bázisosztályból származtatunk.
• Több OO nyelv nem támogatja, mert bonyolult
implementálni.
• Ezekben a nyelvekben interfésszel váltják ki a
többszörös öröklést.
• Leggyakrabban grafikus interfész és a modell
kapcsolatánál használjuk.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
-4 -
Példa: Nyomógomb és callback fv.
A grafikus rendszer kezeli a
felhasználói eseményeket.
Ha megnyomják (áthaladnak fölötte,
elengedik, stb.), meghívja az
alkalmazás megfelelő függvényét
(callback), amit korábban az
alkalmazás közölt a gombbal.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
-5 -
Példa: Kapcsoló
Gombnyomásra ki-be lehessen kapcsolni
– A (grafikus) felhasználói felületen megvalósított gomb megkap
minden felhasználói inputot. Amikor azt kapja, hogy
"megnyomták", akkor szól a kapcsolónak.
• Hogyan szól neki, ha nem ismeri?
• Próbálkozzunk származtatással!
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
-6 -
Kapcsoló a grafikus felületből?
Gomb
callBack()
Kapcsolo
Virtuális fv.
• A grafikának semmi köze
a funkcionalitáshoz!
• Eddig úgy tudtuk, hogy a
Kapcsoló a Drot-ból
származik!
callBack()
Megvalósítás
C++ programozási nyelv
Felhasználói felület (UI)
eleme
© BME-IIT Sz.I.
• A grafikus felülettől függ
a működés?
2021.04.19.
-7 -
Kapcsoló többszörös örökléssel
Drot
GombCallback
Gomb
set
callBack()
cb.obj.ref.
Kapcsolo
UI
Virtuális fv.
callBack()
Funkciójában
ebből származik
Könnyű ilyenné
konvertálni
Megvalósítás
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
-8 -
Kapcsoló megvalósítása
class GombCallback {
// callback funkcióhoz
public:
virtual void callBack() = 0; // virtuális cb. függvény
};
class Gomb { // felhasználói felület objektuma
GombCallback &cb;
// objektum referencia
public:
Gomb (GombCallback &t) :cb(t) {}// referencia inic.
void Nyom() { cb.callBack(); }
// megnyomták
....
};
C++ programozási nyelv
© BME-IIT Sz.I.
GombCallback lehetne
funktor mintájú, amitől
talán elegánsabb a kód,
de könnyen
összeütközhet a modell
függvényhívás
operátorával.
2021.04.19.
-9 -
Kapcsoló megvalósítása/2
class Kapcsolo :public Drot, public GombCallback {
int be; // állapot
public:
Az osztály kompatibilis a GombCallback
void ki();
osztállyal, amin keresztül a Gomb osztály
eléri a callBack függvényt.
void be();
....
void callBack() { if (be) ki(); else be(); } // callback
};
class Gomb {
GombCallback &cb;
Kapcsolo k1;
public:
Gomb g1(k1);
Gomb (GombCallback &t) :cb(t) {}
void Nyom() { cb.callBack(); }
};
https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_09
C++ programozási nyelv
© BME-IIT Sz.I.
nyomogomb
2021.04.19.
- 10 -
Töbsz. öröklés + fv. overload
struct A {
void f() {}
void f(int) {}
};
struct B {
void f(double){}
};
Melyik f?
struct AB : public A, public B {
using A::f;
using B::f;
void f() {
f(1);
f(1.2);
}
};
...
AB ab;
ab.f();
ab.f(5);
ab.f(6.3);
Feltételezés: A többszörös öröklésnél merőben eltérőek az alap-osztályok, az
azonos nevű függvények más-más funkciót látnak el.
https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_09
C++ programozási nyelv
© BME-IIT Sz.I.
polimorf
2021.04.19.
- 11 -
Többszörös öröklés problémái
• Többszörös öröklés különös figyelmet igényel, ha
előfordulhat, hogy egy alaposztály különböző
leszármazottjai "összetalálkoznak".
• Ekkor ún. rombusz v. "diamond" struktúra alakul ki.
• Példa: irodai hierarchia
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 12 -
Irodai hierarchia
Alkalmazott
nev, fizetes
Csop.vez.
csoport
Hat.ideju
ido
Hat.ideju.cs.v.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 13 -
Irodai hierarchia /2
class Alkalmazott {
protected:
String nev;
// név
double fizetes;
// fizetés
public:
Alkalmazott(String n, double fiz);
};
class CsopVez :public Alkalmazott {
csop_t csoport;
// csoport azon.
public:
CsopVez(String n, double f, csop_t cs)
:Alkalmazott(n, f), csoport(cs) { }
};
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 14 -
Irodai hierarchia /3
class HatIdeju :public Alkalmazott {
time_t ido;
// szerződése lejár ekkor
public:
HatIdeju(String n, double f, time_t t)
:Alkalmazott(n, f), ido(t) { }
};
class HatIdCsV :public CsopVez,
public HatIdeju {
public:
HatIdCsV(String n, double f, csop_t cs, time_t t)
:CsopVez(n, f, cs), HatIdeju(n, f, t) { }
};
Két neve és két fizetése van ?
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 15 -
Elérhetők ezek a mezők?
class HatIdCsV :public CsopVez,
public HatIdeju {
public:
HatIdCsV(String n, double f, csop_t cs, time_t t)
:CsopVez(n, f, cs), HatIdeju(n, f, t) { }
void Kiir() {
cout << CsopVez :: nev << endl;
cout << HatIdeju :: nev << endl;
};
C++ programozási nyelv
}
A scope operátorral kiválasztható,
tehát önmagában ez még nem
lenne baj, de baj lehet belőle.
© BME-IIT Sz.I.
2021.04.19.
- 16 -
Memóriakép
Alkalmazott
nev
fizetes
CsopVez
nev
fizetes
csoport
C++ programozási nyelv
HatIdCsV
nev
fizetes
csoport
nev
fizetes
ido
© BME-IIT Sz.I.
HatIdeju
nev
fizetes
ido
2021.04.19.
- 17 -
Miből fakad a probléma ?
• Többszörös elérés az öröklési gráfon.
Miért nem vonja össze a fordító ?
• A nevek ütközése az öröklés megismert szabályai alapján
még nem jelent bajt.
• Lehet hogy szándékos az ütközés.
• Automatikus összevonás esetén a kompatibilitás veszélybe
kerülhet.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 18 -
Megoldás: Virtuális alaposztály
class CsopVez :virtual public Alkalmazott {
....
Csak az öröklési lánc legvégén hívódik
public:
meg az alaposztály konstruktora.
CsopVez(String n, double f, csop_t cs)
:Alkalmazott(n, f),// csak lánc végén
csoport(cs) { }
};
class HatIdeju :virtual public Alkalmazott{ .... };
class HatIdCsV :public CsopVez, public HatIdeju {
public:
HatIdCsV(String n, double f, csop_t cs, time_t t)
:Alkalmazott (n, f),
// csak ha a lánc vége
CsopVez(NULL, 0, cs), // tudjuk, hogy az ős konstr.
HatIdeju(NULL, 0, t) { } // nem itt hívódik, ezért null
https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_09
C++ programozási nyelv
© BME-IIT Sz.I.
iroda
2021.04.19.
- 19 -
Virtuális alaposztály
1. Alaposztály adattagjai nem épülnek be a származtatott
osztály adattagjaiba. A virtuális függvényekhez hasonlóan
indirekt elérésűek lesznek.
2. Az alaposztály konstruktorát nem az első származtatott
osztály konstruktora fogja hívni, hanem az öröklési lánc
legvégén szereplő osztály konstruktora.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 20 -
Memóriakép virt. alaposztállyal
Alkalmazott
nev
fizetes
CsopVez
csoport
virtual
&Alkalmazott
HatIdCsV
csoport
nev
fizetes
&Alkalmazott
ido
nev
fizetes
C++ programozási nyelv
© BME-IIT Sz.I.
HatIdeju
ido
&Alkalmazott
nev
fizetes
&Alkalmazott
2021.04.19.
- 21 -
Irodai példa virt. alaposztállyal
class Alkalmazott { ... };
class HatIdeju :virtual public Alkalmazott{ ... };
class CsopVez :virtual public Alkalmazott { ... };
class HatIdCsV :public CsopVez, public HatIdeju { ... };
class HatIdCsVH :public HatIdCsV { ... };
Melyik konstruktor hívja az Alkalmazott konstruktorát ?
Alkalmazott melos("Lusta Dick", 100); // Alkalmazott
HatIdeju grabo("Grabovszki", 300); // HatIdeju
CsopVez fonok("Mr. Gatto ", 5000); // CsopVez
HatIdCsV gore("Mr. Tejfel", 3000); // HatIdCsV
HatIdCsVH ("Safranek", 500); // HatIdCsVH
Aki a lánc végen van.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 22 -
És, ha nem lenne virtuális ?
class Alkalmazott { ... };
class HatIdeju :public Alkalmazott{ ... };
class CsopVez :public Alkalmazott { ... };
class HatIdCsV :public CsopVez, public HatIdeju { ... };
class HatIdCsVH :public HatIdCsV { ... };
Melyik konstruktor hívja az Alkalmazott konstruktorát ?
Alkalmazott melos("Lusta Dick", 100); // Alkalmazott
HatIdeju grabo("Grabovszki", 300); // HatIdeju
CsopVez fonok("Mr. Gatto ", 5000); // CsopVez
HatIdCsV gore("Mr. Tejfel", 3000); // CsopVez, HatIdeju
HatIdCsVH ("Safranek", 500); // CsopVez, HatIdeju
Aki az első a láncban.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 23 -
Elkerülhető a többsz. öröklés?
• Egyes OO nyelvekben nincs többszörös öröklés, de van
helyette interfész, amivel pótolható a hiánya. C++ -ban
ilyen nincs, ezért teljesen nem kerülhető el.
• Biztosan nem kerülhető el, ha
– mindkét osztály "arcát" mutatni kell (pl. ny.gomb)
– mindkét osztályt valamiért alaposztállyá kell konvertálni (upcast)
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 24 -
Konstruktor feladatai
• Öröklési lánc végén hívja a virtuális alaposztályok
konstruktorait.
• Hívja a közvetlen, nem virtuális alaposztályok
konstruktorait.
• Létrehozza a saját részt:
– beállítja a virtuális alaposztály mutatóit
– beállítja a virtuális függvények mutatóit
– hívja a tartalmazott objektumok konstruktorait
– végrehajtja a programozott törzset
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 25 -
Destruktor feladatai
• Megszünteti a saját részt:
– végrehajtja a programozott törzset
– tartalmazott objektumok destruktorainak hívása
– virtuális függvénymutatók visszaállítása
– virtuális alaposztály mutatóinak visszaállítása
• Hívja a közvetlen, nem virtuális alaposztályok
destruktorait.
• Öröklési lánc végén hívja a virtuális alaposztályok
destruktorait.
https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_09
C++ programozási nyelv
© BME-IIT Sz.I.
ctor_dtor
2021.04.19.
- 26 -
Hívható-e konstruktorból saját virt. fv?
• Hivható, de nem az történik, amit várunk. Az alaposztály
konstruktora a származtatott obj. konstruktora előtt fut le,
így a virtuális függvénypointerek beállítása nem történik
meg.
B konstr. még
nem futott.
struct A {
A() { f(); }
virtual void f() { cout << "A::f";}
};
struct B :public A {
B() { }
void f() { cout << "B::f"; }
};
C++ programozási nyelv
© BME-IIT Sz.I.
Kiírás: A::f
2021.04.19.
- 27 -
Hívható-e destruktorból saját virt. fv?
• Hívható, de nem az történik, amit várunk. Az alaposztály
destruktora a származtatott obj. destruktora után fut le, így
a virtuális függvénypointerek már visszaálltak.
B destr. már
lefutott.
struct A {
~A() { f(); }
virtual void f() { cout << "A::f";}
};
struct B :public A {
~B() { }
void f() { cout << "B::f"; }
};
C++ programozási nyelv
© BME-IIT Sz.I.
Kiírás: A::f
2021.04.19.
- 28 -
Konstruktor/destruktor, mint őrszem
• Gyakori, hogy erőforrásként kell kezelni valamit (memória,
fájl, eszköz, stb.):
– lefoglalás
– feldolgozás
– felszabadítás
• Az ilyen esetekben külön figyelmet kell fordítani arra, hogy
a feldolgozás közben észlelt hiba esetén is gondoskodjunk a
felszabadításról.
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 29 -
Konstruktor/destruktor, mint őrszem/2
{ // Kódrészlet
...
std::ifstream inp(f); // megnyitás
...
// file feldolgozása
if (inp.fail())
throw "baj_van"; // !!! nincs lezárva a fájl !!!
inp.close();
// lezárás normál esetben
}
A példa sántít, mert az ifstream a példány megszűnésekor bezárja a fájlt.
Köszönöm Anonymus előadáson tett megjegyzését!
Így azzal a hamis feltételezéssel nézzék a példát, minta nem zárná be, vagy
ifstream helyett valami eszközt (pl. hálózat) használunk, amit külön be kell zárni.
A lényeg a konstruktor/destruktor őrszem jellegű felhasználásában van.
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 30 -
Konstruktor/destruktor, mint őrszem/3
// Adapter, ami mindent tud, amit az ifstream + megszűnéskor bezár
struct Inputstream : std::ifstream {
Inputstream(const char *f) :std::ifstream(f) {}
~Inputstream() { close(); }
atomatikusan
};
bezár
{ // Kódrészlet
Inputstream inp(f); // megnyitás
...
// file feldolgozása
}
destruktor megszüntet (bezár)
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 31 -
Mutatókonverzió újra
• Származtatott osztály a kompatibilitás révén könnyen
konvertálható alaposztályra.
• Ez hívjuk "upcast"-nak.
• Leggyakrabban pointereket konvertálunk (heterogén
gyűjtemény).
• Néha referenciát. (copy konstruktor hívása)
• Többszörös öröklésnél a konverzió nagy figyelmet igényel.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 32 -
Mut. konv. többszörös öröklésnél
Alap1 * pB1
Alap2 * pB2
alap1
alap2
új rész
MulDer md;
memóriakép
kompatibilis
class Alap1 { ... };
class Alap2 { ... };
class MulDer: public Alap1, public Alap2 { ... };
MulDer md;
Alap1 * pB1 = &md;
Alap2 * pB2 = &md;
// mutató értékmódosítás!
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 33 -
Konv. többsz. öröklésnél szárm.-ra
MulDer * pMd
alap1
alap2
b2
új rész
Alap2 b2;
MulDer *pmd = (MulDer *) &b2;
// mutató értékmódosítás!
// nem létező adatmezőket és üzeneteket el lehet érni
// explicit konverzió mindig veszélyes!
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 34 -
Megbocsátható down cast
• Néha előfordul, hogy tudjuk, hogy egy adott mutató egy
származtatott osztályból származik, de valamiért alappá
konvertáltuk (pl. heterogén kollekció)
• Ekkor biztonságos a dynamic_cast használata, ami futási
időben értékelődik ki.
Ha MulDer* típusú, akkor
OK, egyébként NULL
MulDer md;
Alap *p = &md;
MulDer *pa = dynamic_cast<MulDer*>(p);
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 35 -
cast átértékelése
C: (típus)
Explicit típuskonverziót végez. Használata
körültekintést igényel. C programokban
leginkább a malloc környékén fordul elő joggal.
Eredménye nem lvalue.
C++:
Sokkal többször és sokkal több okból fordulhat
elő joggal. A veszélyek csökkentésére több
változata létezik: (dynamic_cast, static_cast,
const_cast, reinterpret_cast, (tipus), tipus())
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 36 -
dynamic_cast
szintaxis: dynamic_cast<T>(v)
v – alaposztályra hivatkozik, vagy pointer
T – származtatott osztályra hivatkozik, vagy void
pointer
struct A {
virtual ~A(){}
};
struct B :A {};
struct C :A {};
NULL
C++ programozási nyelv
polimorf
A* apB = new B;
A* apC = new C;
B* bp1 = dynamic_cast<B*>(apB);
B* bp2 = dynamic_cast<B*>(apC);
© BME-IIT Sz.I.
2021.04.19.
- 37 -
static_cast
szintaxis: static_cast<T>(v)
v – alaposztályra hivatkozik, vagy pointer
T – származtatott osztályra hivatkozik, vagy void
pointer
struct A {
};
struct B :A {};
struct C :A {};
A* apB = new B;
A* apC = new C;
B* bp1 = static_cast<B*>(apB);
B* bp2 = static_cast<B*>(apC);
Fordítási időben történik, nincs futás idejű ellenőrzés!
Jelzi, ami fordítási időben tilos. (pl. int* -> B*)
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 38 -
const_cast
szintaxis: const_cast<T>(v)
Csak a const vagy a volatile minősítő
eltávolítására vagy előírására használható.
const int a = 10;
const int* b = &a;
int* c = const_cast<int*>(b);
*c = 30; //nincs ford.hiba. !!Nem definit!!
int a1 = 40;
const int* b1 = &a1;
int* c1 = const_cast<int*>(b1);
*c1 = 50; // minden OK, mert a1 nem konst.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 39 -
reinterpret_cast
szintaxis: reinterpret_cast<T>(v)
Ellenőrzés és változtatás nélkül átalakítja v-t a
megadott típusúvá. Igen veszélyes, de
legalább könnyen felismerhető a forrásban.
A const ill. volatile minősítés nem
módosítható vele.
struct B {};
B* p = new B;
long l = reinterpret_cast<long>(p);
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 40 -
(típus), típus( )
A C stílusú cast mellett használható még az
úgynevezett funkció stílusú cast is.
Lehetőleg az úgynevezett nevesített
(dynamic_cast, static_cast, const_cast,
reinterpret_cast) változatokat kell használni.
Használatukkal a konverziókból adódó
problémák sokkal könnyebben felfedezhetők.
int i, j; double d;
d = (double)i/j;
d = double(i)/j; // funkció stílusú cast
https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_09
C++ programozási nyelv
© BME-IIT Sz.I.
polimorf
2021.04.19.
- 41 -
Explicit konstruktor (ism.)
• Az egyparaméterű konstruktorok egyben
automatikus konverziót is jelentenek:
pl: String a = "hello";
String a = String("hello");
• Ez kényelmes, de zavaró is lehet:
– tfh: van String(int) – konstruktor, ami megadja a
string hosszát, de nincs String(char) konstruktor;
– ekkor: String b = 'x'; String b =String(int('x'));
nem biztos, hogy kívánatos.
• Az aut. konverzió az explicit kulcsszóval
kapcsolható ki. (pl: explicit String(int i);)
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 42 -
Explicit konstruktor példa:
class Komplex {
double re, im;
public:
Komplex(double re = 0, double im = 0)
:re(re), im(im){ }
};
void valamifv(class Komplex);
int main() {
Komplex k1 = 12; // OK.
...
valamifv(12); //Lehet, hogy nem ezt akarta, esetleg
// elfelejtette megvalósítani az int-es változatot.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 43 -
Perzisztencia
Obj
Obj
Attr.
Attr.
• A perzisztens objektumok állapota elmenthető és
visszatölthető egy későbbi időben, esetleg másik gépen
létrehozott objektumba.
• A visszatöltött objektum "folytatja" a működést.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 44 -
Perzisztencia/2
• Az objektum a saját állapotát képes kiírni egy
adatfolyamba
szerializáció
• Az objektum a saját állapotát képes beolvasni egy
adatfolyamból
deszerializáció
• Szempont lehet a hordozható külső formátum is. Ez
különösen fontos elosztott rendszereknél.
• A perzisztenciát gyakran többszörös örökléssel vagy
interfésszel oldják meg.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 45 -
Perzisztencia örökléssel I./1
class Serialize {
int size;
// kírandó adat mérete
public:
Serialize(int s) :size(s) {} // méret beállítása
void write(ostream& os) const {
os.write((char *)this, size); // kiírás
}
void read(istream& is) const {
is.read((char *)this, size);
// beolvasás
}
};
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 46 -
Perzisztencia örökléssel I./2
class Complex {
Képes kiírni ill. visszatölteni
double re, im; ....
}
class PComplex : public Serialize, public Complex {
public:
PComplex(double re, double im) : Complex(re, im),
Serialize(sizeof(PComplex)) {}
};
Származtatott mérete
int main() {
int main() {
ifstream f1("f1.dat");
ofstream f1("f1.dat");
PComplex k1(1, 8);
PComplex k1;
k1.read(f1);
k1.write(f1);
return 0;
return 0;
}
}
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 47 -
A sorrendre érzékeny!
class PComplex : public Serialize, public Complex { ... }
Complex
Serialize
re
im
size
write((char*)this,size)
PComplex:: this
Serialize:: this
PComplex
size
re
im
Complex:: this
re
im
size
class PComplex : public Complex, public Serialize { ... }
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 48 -
Problémák
• Pointerek visszatöltésének nincs értelme.
• Veszélyes a kód: A öröklés sorrendjére érzékeny. A
Serialize osztálynak kell elsőnek szerepelni.
• Mi van a virtuális függvények mutatóival?
• Külső reprezentáció nem hordozható.
• Ötletnek nem rossz, de a gyakorlatban
használhatatlan!
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 49 -
Van megoldás?
• C++-ban nehéz automatizálni a szerializációt. Néhány
könyvtár ad támogatást (pl. boost, MFC, s11n)
• Fapados, de működő megoldás:
– Magára az objektumra kell bízni az adatfolyammá történő
alakítást ill. visszaalakítást.
– Ehhez célszerű egy olyan absztrakt osztályból származtatni, ami
megfelel az elvárt interfésznek („arcnak”). ld: Serializable
• Kellő körültekintéssel el kell készíteni a megfelelő virtuális
függvényeket.
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 50 -
Használható megoldás
class Serializable {
Absztrakt osztály a sorosításhoz
public:
virtual void write(ostream& os) const = 0; // kiíró
virtual void read(istream& is) = 0;
// beolvasó
virtual ~Serializable() {} // ne legyen probléma az upcast
};
class String {
Szebb lenne protected nélkül.
protected:
Hogyan? Pl: getter/setter, vagy
char *p;
inserter/exractor (ld. laboron)
int len;
public:
String(char *s = "" ) {
len = strlen(s);
p = new char[len+1]; strncpy(p, s, len+1);
}
.....
};
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 51 -
Használható megoldás /2
class PString : public Serializable, public String {
Így két „arca” lesz
public:
void write(ostream& os) const;
Világos, hogy ezek kellenek
void read(istream& is);
... // Milyen tagfüggvény kell még, ha azt akarjuk, hogy
// PString String helyett használható legyen ?
};
• String összes létrehozási lehetősége
• Kell másoló? Kell op=?
Kell minden konstruktor
– Van dinamikus adattagja a PStringnek? Nincs.
Így nem kell.
• Mi van, ha valamilyen String művelet eredményét PString-re kellene
konvertálni?
– Kell String
PString konverzió
Konstruktorok megoldják
• Mi van, ha valamilyen PString művelet eredményét String-re kellene
konvertálni? Kompatibilitás megoldja
• Destruktor? Jó az örökölt
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 52 -
Használható megoldás /3
class PString : public Serializable, public String {
public:
PString() : String() {};
PString(char ch) :String(ch) {}
PString(const char *p) :String(p) {}
PString(const String& s) :String(s) {}
void write(ostream& os) const;
void read(istream& is);
};
// Már csak a write és a read megvalósítása hiányzik!
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 53 -
write és read megvalósítása
// Feltételezzük, hogy String::p és String::len protected tag,
// de később belátjuk, hogy nem is kell!
void PString::write(ostream& os) const {
os << len << ',';
// szeparátor
os.write(p, len);
// a szöveg kiírása
}
void PString::read(istream& is) {
delete[] p;
(is >> len).ignore(1); // len és szeparátor beolvasás
p = new char [len+1]; // új terület kell
is.read(p, len);
// len db karaktert olvasunk
p[len] = 0;
// lezáró nulla
}
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 54 -
write és read megvalósítása /2
void PString::write(ostream& os) const {
Protected nélkül.
os << size() << ','; // méret + szeparátor
os.write(c_str(), size());// a szöveg kiírása
os << '\n';
// csak a könnyebb debug miatt
}
Miért read és nem >> ?
void PString::read(istream& is) {
size_t len;
(is >> len).ignore(1);// len és szeparátor beolvasása
char *p = new char [len+1]; // új terület
is.read(p, len).ignore(1); // len db karaktert olvasunk + a \n
p[len] = 0;
// lezáró nulla
*this = String(p); // kihasználjuk, hogy az op= működik
delete [] p;
// p már nem kell
}
https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_09
C++ programozási nyelv
© BME-IIT Sz.I.
pkomplex (a pstring házi feladat)
2021.04.19.
- 55 -
Kérdések, megjegyzések
• Fontos, hogy a read() pontos tükörképe legyen a write()-nak.
• Fontos a megfelelő reprezentáció kiválasztása.
• Kézenfekvő mindent szöveggé alakítani. Ekkor numerikus kiírások
után kell szeparátor, amit a beolvasáskor el kell dobni.
• Célszerű binárisan megnyitott adatfolyamot (stream) használni, így
elkerülhetők a \n \r\n konverzióból adódó problémák a különböző
rendszerek között.
• Pointerek és referenciák kezelése külön figyelmet igényel.
• Miért kell többszörös öröklés?
– ha módosítható az osztály – megoldható többsz. nélkül
– ha nincs kezünkben az osztály – csak ez a lehetőség
C++ programozási nyelv
© BME-IIT Sz.I.
2021.04.19.
- 56 -
Kivételes esetek kezelése (ism.)
• Kinek kell jelezni?
– felhasználó, másik programozó, másik program
– saját magunknak
• A kivételes eset kezelése gyakran nem annak keletkezési
helyén történik. (Legtöbbször nem tudjuk, hogy mit kell
tenni. Megállni, kiírni valami csúnyát, stb.)
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 57 -
Kivétel kezelés (ism.)
• C++ típus orientált kivételkezelést támogat, amivel a
kivételes esetek kezelésének szinte minden formája
megvalósítható.
• A kivételkezeléshez tartozó tevékenységek:
– figyelendő kódrészlet kijelölése (try)
– kivétel továbbítása (throw)
– esemény lekezelése (catch)
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 58 -
Kivételkezelés = globális goto (ism)
Fv.
try
Kivételes
eset: throw A
Felügyelt műveletek
beleértve az innen
hívott függvényeket is.
catch
Kivétel elkapása,
típus alapján, és
kezelése.
Kivételes
eset: throw B
C: setjmp( )
longjmp( )
C++ programozási nyelv © BME-IIT Sz.I.
További műv.
A: A típusú érték
B: B típusú érték
2021.04.19.
- 59 -
Kivételkezelés/2 (ism)
try {
..... Kritikus művelet1 pl. egy függvény hívása, aminek a
belsejében:
if (hiba) throw kifejezés_tipus1;
..... Kritikus művelet2 pl. egy másik függvény hívása,
aminek a belsejében: if (hiba) throw kifejezés_tipus2;
} catch (típus1 param) {
..... Kivételkezelés1
} catch (típus2 param) {
..... Kivételkezelés2
} A hiba tetszőleges mélységben keletkezhet.
Közvetlenül a try-catch blokkban a throw-nak nincs sok értelme,
hiszen akkor már kezelni is tudnánk a hibát.
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 60 -
Kivételkezelés példa (ism)
Hiba/kivétel
észlelése
Felügyelt szakasz.
Ennek a működése
során fordulhat elő
a kivételes eset.
C++ programozási nyelv © BME-IIT Sz.I.
double osztas(int y)
{
if (y == 0)
throw "Osztas nullaval";
return((5.0/y);
}
A kivételt azonosító
érték eldobása.
Típus azonosít
(köt össze).
int main()
{
try {
cout << "5/2 =" << osztas(2) << endl;
cout << "5/0 =" << osztas(0) << endl;
} catch (const char *p) {
cout << p << endl;
Kivétel elkapása és
}
kezelése.
}
2021.04.19.
- 61 -
Újdonságok a korábbiakhoz
• A dobott kivétel alap ill. származtatott
objektum is lehet.
try {
throw E();
} catch(H) {
// mikor jut ide ?
}
1.
2.
3.
4.
H és E azonos típusú,
H bázisosztálya E-nek,
H és E mutató és teljesül rájuk 1. vagy 2.,
H és E referencia és teljesül rájuk 1. vagy 2.
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 62 -
Következtetések
• Célszerű kivétel osztályokat alkalmazni, (pl.
std::exceptions) amiből származtatással újabb kivételeket
lehet létrehozni.
• A dobás értékparamétert dob, ezért az elkapáskor számolni
kell az alaposztályra történő konverzióval (adatvesztés).
Célszerű pointert, vagy referenciát alkalmazni.
Kell másoló konstruktor.
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 63 -
Továbbdobás
try {
throw E();
} catch(H) {
if (le_tudjuk kezelni) {
Az eredeti dobódik tovább,
nem csak az elkapott
....
változat.
} else {
throw;
}
Paraméter nélkül
}
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 64 -
Minden elkapása
try {
throw E();
} catch(...) {
// szükséges feladatok
throw;
}
Minden kivétel
A kezelők sorrendje fontos!
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 65 -
Rollback (stack unwinding)
try {
Minden a blokkban deklarált, "létező"
A a;
objektum destruktora meghívódik.
B b;
C *cp = new C;
if (hiba) throw "Baj van";
delete cp;
} catch(const char *p) {
Hiba esetén C példánya nem
// A létezik ?
szabadul fel, de cp megszűnik.
// B létezik ?
// *cp által mutatott obj. létezik ?
}
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 66 -
Melyik obj. létezik ?
• Csak az az objektum számít létezőnek, amelynek a
konstruktora lefutott.
• Ha a konstruktor nem fut le, akkor a rollback során a
destruktor sem fog végrehajtódni.
• Előző példában C konstruktora lefutott ugyan, de
nem deklarációval hoztuk létre, hanem dinamikusan.
https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_9
C++ programozási nyelv © BME-IIT Sz.I.
kodreszletek
2021.04.19.
- 67 -
Kivétel a konstruktorban
• Lényegében a kivételkezelés az egyetlen mód arra, hogy a
konstruktor hibát jelezzen.
• Hiba esetén gondoskodni kell a megfelelő obj. állapot
előállításáról.
Inicializáló listán keletkező kivétel elfogása:
struct A {
B b;
A() try
:b() { // konstruktor programozott része
} catch (...) {
... // kivételkezelés
// ha eljut idáig itt továbbdob
}
};
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 68 -
Kivétel a destruktorban
Destruktor hívás oka:
1. Normál meghívás
2. Kivételkezelés (rollback) miatti meghívás.
Ekkor a kivétel nem léphet ki a
destruktorból.
Destruktorban keletkező kivétel elfogása:
A::~A() try {
// destruktor programozott törzse
} catch (...) {
... // kivételkezelés
// ha eljut idáig, továbbdob
}
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 69 -
Kivételek specifikálása
• Függvény deklarálásakor/definíciójakor
megadható, hogy milyen kivételeket generál
az adott függvény.
• Ha mást is generálna, akkor az automatikusan
meghívja az unexpected() handlert.
void f1() throw (E1, E2); // csak E1, E2
void f2() throw();
// semmi
void f3();
// bármi
void f3() noexcept(true)
// semmi (C++11-től)
C++17-től megszűnik a függvények din. kivétel specifikációja. Csak dob/nem dob.
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 70 -
Kapcsolódó függvények
• std::terminate_handler
set_terminate(std::terminate_handler) throw();
– beállítja a terminate handlert
• void terminate();
– meghívja a terminate handlert
• bool uncaught_exception() throw();
– kivételkezelés folyamatban van, még nem talált rá a
megfelelő handlerre (nem kapták el). Destruktorban lenne
szerepe, de …
C++11-től a szignatúra változik
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 71 -
Összefoglalás
• Többszörös öröklés: Ha egy osztálynak több „arcot” kell mutatnia.
pl.
– UI és modell kapcsolata
– perzisztencia
• Sorosítás fontos eszköz a kommunikációban. C++-ban nehéz
automatizálni, de egyedi megoldásokra van működő recept.
• Explicit cast veszélyes. Könnyebb felismerhetőséghez több
eszközünk van (pl. dynamic_cast, const_cast, ...)
• Kivételes esetek kezelését átértékeltük az öröklés ismeretében
C++ programozási nyelv © BME-IIT Sz.I.
2021.04.19.
- 72 -
