Útmutató a 6. laborhoz

A laborgyakorlat a tartalmazott objektumok és ősök létrehozásával, inicializálásával, valamint megszüntetésével kapcsolatos mechanizmusok és automatizmusok bemutatását, jobb megértését célozza. Sok apró feladatot kell megoldania, melyek közül felkészültsége alapján ki is hagyhat néhányat. Önellenőrzés céljából csak a 3. feladatcsoport megoldásaként elkészülő bicikli.h fájlt kell feltöltenie a Jporta rendszerbe.

Válaszoljon az alábbi kérdésekre, majd ellenőrizze válaszát. Ha nem sikerült mindenre hibátlanul válaszolni, akkor feltétlenül oldja meg az első két feladatcsoport minden feladatát!

Ellenőrző kérdések:

Tételezze fel, hogy B osztály egyik adattagja A típusú, ami szintén osztály!
1. B implicit deklarált másoló konstruktora meghívja-e A másoló konstruktorát?
  
  Ellenőrizze válaszát!
  Igen.
2. B implicit deklarált másoló konstruktora nem felel meg a feladat elvárásainak, ezért Ön készíti el B másoló konstruktorát, de az inicializáló listát üresen hagyja. Meghívódik-e A valamelyik konstruktora. Ha igen, melyik?
  
  Ellenőrizze válaszát!
  Igen, a paraméter nélkül hívható konstruktor.
Tételezze fel, hogy BB osztály ősosztálya AA osztály!
1. BB osztályból dinamikus adatterületen létrehozott példány címét az AA *ap pointer tárolja.
  A delete ap; utasítás hatására mikor fut le ~BB()?
  
  Ellenőrizze válaszát!
  Ha AA destruktora virtuális.
2. Amennyiben BB-nek csak implicit deklarált konstruktora van. AA-nak melyik konstruktora hívódik meg a
  new BB; utasítás hatására?
  
  Ellenőrizze válaszát!
  A paraméter nélkül hívható konstruktor.

Laborfeladatok megoldásokkal

Az objektumosztályok kapcsolatát osztálydiagramok segítségével írjuk le, amit legtöbbször UML (Unified Modelling Language) ábrák segítségével adunk meg. Az UML szintaktikájával, és lehetőségeivel a következő félévben fognak részletesen megismerkedni. Ebben a félévben csak néhány egyszerű jelölést használunk, mint pl. a láthatóság és default értékek jelölése. Az UML ábrákon a tagfüggvények és adattagok láthatóságát a nevük előtt álló +, -, vagy # jellel jelöljük. A - jel a privát, + jel a publikus, a # pedig a védett (protected) láthatóságot jelenti. A default értékek és argumentumok a C++ szintaxisához nagyon hasonlóan jelennek meg.

1. feladatcsoport. (~35')

Egy egykerekű (Monocikli) egyszerűsített modelljét építjük fel, melyben a monocikli csak egyetlen komponensből áll: egy kerékből. A komponens relációnak (kompozíció) megfelelően elkészítettük a modell osztálydiagramját:

Feladatok:

A feladat egyszerűsége miatt nem szükséges osztályonként külön fájlokat létrehoznia. A deklarációt és az implementációt (külön *.h és *.cpp állományok) sem kell szeparálnia, mindent írhat egyetlen fájlba (pl. monocikli.cpp)! A tagfüggvények mindegyike legyen inline megvalósítású, így kevesebbet kell gépelnie.

Valósítsa meg a Kerek és Monocikli osztályokat C++ nyelven! Az egyszerűség kedvért az osztályoknak az alapértelmezett tagfüggvényeken kívül ne legyen más metódusa!
Ellenőrizze megoldását
```
class Kerek {
    int atmero;
};

class Monocikli {
    Kerek k;
};
```
Ezután egészítse ki az osztályokat az alábbiaknak megfelelő tagfüggvényekkel, melyek egyszerű üzeneteket írnak a standard kimenetre. Minden kiírást egy tabulátorjellel (\t) kezdjen!
- A Kerek osztály konstruktora írja ki, hogy: \tKerek ctor\n!
- A Monocikli osztály konstruktora írja ki, hogy: \tMonocikli ctor\n!
- A Kerek osztály destruktora írja ki, hogy: \tKerek dtor\n!
- A Monocikli osztály destruktora írja ki, hogy: \tMonocikli dtor\n!
???
```
class Kerek {
    int atmero;
public:
    Kerek()             { std::cout << "\tKerek ctor\n"; }
    ~Kerek()            { std::cout << "\tKerek dtor\n"; }
 };

class Monocikli {
    Kerek k;
public:
    Monocikli()         { std::cout << "\tMonocikli ctor\n"; }
    ~Monocikli()        { std::cout << "\tMonocikli dtor\n"; }
 };
```
Próbálja ki az alábbi főprogrammal a létrehozott osztályokat:
```
#include <iostream>
/// Utasítást kiíró és végrehajtó makró
#define _(x)  std::cout << #x << std::endl; x

int main() {
_(    Monocikli m1_obj;          )
_(    Monocikli m2_obj = m1_obj; )
_(    return 0;                  )
}
```
Ha jól csinált mindent, akkor az alábbiakat kell látnia:
```
Monocikli m1_obj;
    Kerek ctor
    Monocikli ctor
Monocikli m2_obj = m1_obj;
return 0;
    Monocikli dtor
    Kerek dtor
    Monocikli dtor
    Kerek dtor
```
Ha nem ezt kapta, próbálja lépésenként végrehajtani a programot! Ne lépjen addig a következő feladatra, amíg nem érti mi miért történt! Kérjen segítséget a laborvetetőtől, ha elakadt!

A programot elemezve látható, hogy az _( makró kiírja magát az utasítást és egy soremelést. Ezt követően az Ön kiírásai jelennek meg a tabulator miatt kicsit beljebb. Így jól felismerhető, hogy melyik utasításból milyen output keletkezett.

Bővítse a Kerek osztályt egy publikus kiir() tagfüggvénnyel, ami kiírja a kerék átmérőjét:

    void kiir()         { std::cout << "atmero=" << atmero << std::endl; }

A Monocikli osztályt is bővítse egy kiír tagfüggvénnyel, ami meghívja az általa tartalmazott kerék objektum kiíró tagfüggvényét:

    void kiir()         { std::cout << "\tk."; k.kiir(); }

A main függvényt pedig alakítsa át az alábbiaknak megfelelően:

int main() {
_(    Monocikli m1_obj;          )
_(    m1_obj.kiir();             )
_(    Monocikli m2_obj = m1_obj; )
_(    m2_obj.kiir();             )
_(    return 0;                  )
}

Majd futtassa a programot!

Milyen értéket kapott atmero-re? Ezt várta? Egyezik a két érték? Ha jól oldotta meg a feladatokat, akkor az alábbi kiíráshoz hasonlót kell látnia:
```
Monocikli m1_obj;
    Kerek ctor
    Moncikli ctor
m1_obj.kiir();
    k.atmero=123456789
Monocikli m2_obj = m1_obj;
m2_obj.kiir();
    k.atmero=123456789
return 0;
    Monocikli dtor
    Kerek dtor
    Monocikli dtor
    Kerek dtor
```
Az adattagokban azonos memóriaszemét van. Miért?
Az m1_obj objektum atmero adattagja inicializálatlanul jött létre, amit az osztály implicit deklarált másoló konstruktora lemásolt amikor létrejött az m2_obj objektum m1 másolataként. Jegyezze meg, hogy az implicit deklarált másoló konstruktor az adattagokat lemásolja, illetve meghívja azok másoló konstruktorát, ha van ilyen.
Készítsen a Kerek osztályhoz másoló konstruktort, ami csupán kiírja a szabványos kimenetre, hogy: \tKerek copy\n!
???
```
    Kerek(const Kerek&) { std::cout << "\tKerek copy\n"; }
```
Futtassa ismét a programot! Vesse össze a kiírásokat az előző futás eredményével! Mit tapasztal? Lemásolódott az atmero adattag?
Módosítsa a Kerek osztály másoló konstruktorát, hogy az adattag is másolódjon le (inicializáló lista)! Majd futtassa ismét a programot!
???
```
    Kerek(const Kerek& k) :atmero(k.atmero) 
                        { std::cout << "\tKerek copy\n"; }
```

Azt kell látnia, hogy most a Kerek osztály másoló konstruktora nem hívódott meg automatikusan. Milyen tagfüggvény hívódik meg helyette? Miért?

Készítsen Monocikli osztályhoz is másoló konstruktort, ami csupán kiírja a szabványos kimenetre, hogy: \tMonocikli copy\n! Futtassa ismét a programot! Vesse össze a kiírásokat az előző futás eredményével! Mit tapasztal?

Oldja meg, hogy akkor is hívódjon a Kerek osztály másoló konstruktora, amikor a Monocikli osztálynak is van explicit módon megadott másoló konstruktora (inicializáló lista)! Ha jól oldotta meg a feladatot, akkor a két objektum (m1, m2) adattagja azonos értéket (memóriaszemetet) tartalmaz.

Ellenőrizze válaszát!
Amennyiben az implicit (automatikusan) keletkező függvényeket felüldefiniáljuk, akkor abban csak az történik, amit abba belekódolunk. Ha a másoló konstruktorból nem hívjuk meg a tartalmazott osztály egyik konstruktorát sem, akkor automatikusan meghívódik a paraméter nélkül hívható, mivel valahogy létre kell hozni az objektumot.

A kódot kiegészítve meg tudjuk hívni a tartalmazott objektum másolóját:

???

    Monocikli(const Monocikli& m) :k(m.k) 
                        { std::cout << "Monocikli copy\n";}

A Kerek osztály konstruktora vegyen át egy int paramétert, amivel inicializálja az atmero adattagot! A paraméternek ne legyen default értéke! Így a Kerek osztálynak most nincs paraméter nélkül hívható (default) konstruktora. Fordítsa le a programot! Mit tapasztal? Lefordul?

Ellenőrizze válaszát!
Nem fordul le, mivel nem tud létrejönni a Kerek osztály példánya. Nincs paraméter nélkül hívható konstruktora.
A Monocikli osztály paraméter nélkül hívható konstruktorának inicializáló listáján inicializálja a k adattagot 16-tal! Így már lefordul a kód, pedig most sincs paraméter nélkül hívható konstruktora a Kerek osztálynak.
Miért?
Így az egyparaméteres konstruktor hozza létre k-t. Nincs szükség a paraméter nélkülire.
```
    Monocikli() :k(16)   { std::cout << "Monocikli ctor\n";}
```
Törölje a Monocikli osztály destruktorát!, és futtassa ismét a programot! Vegye észre, hogy a Kerek osztály destruktora akkor is meghívódik, ha van a Monocikli osztálynak explicit módon megadott destruktora!

Miért?
A destruktor eltérően viselkedik: A tartalmazott osztály destruktora midig meghívódik. Azt nem kell (nem szabad) explicit módon hívni. A dolog logikus: az objektumnak mindenképpen meg kell szűnnie.
Hasonló okból a tartalmazott osztály paraméter nélkül hívható konstruktora is automatikusan meghívódik, ha nem hívjuk meg explicit módon a tartalmazott osztály egyik konstruktorát sem, mivel az objektumnak létre kell jönnie. A különbség csak annyi, hogy a konstruktorból több is lehet, így a választást a kezünkbe adja a fordító.
A végleges kódrészlet így nézhet ki:
```
class Kerek {
    int atmero;
public:
    Kerek(int d) :atmero(d)
                        { std::cout << "\tKerek ctor\n"; }
    Kerek(const Kerek& k) :atmero(k.atmero)
                        { std::cout << "\tKerek copy\n"; }
    void kiir()         { std::cout << "atmero=" << atmero << std::endl; }
    ~Kerek()            { std::cout << "\tKerek dtor\n"; }
 };

class Monocikli {
    Kerek k;
public:
    Monocikli() :k(16)  { std::cout << "Monocikli ctor\n";}
    Monocikli(const Monocikli& m) :k(m.k)
                        { std::cout << "Monocikli copy\n";}
    void kiir()         { std::cout << "\tk."; k.kiir(); }
 };
```

2. feladatcsoport. (~35')

Járművek modellezéséhez készítünk egyszerű objektummodellt, melyben közös attribútumnak a jármű maximális sebességét választottuk. Modellünkkel kezdetben csak kutyákkal húzott szánkót (Szan) modellezünk. Az alábbi ábra ezen egyszerű modell osztálydiagramját szemlélteti.

Feladatok:

A feladat egyszerűsége miatt itt sem szükséges osztályonként külön fájlokat létrehoznia. A deklarációt és az implementációt (külön *.h és *.cpp állományok) sem kell szeparálnia, mindent írhat egyetlen fájlba (pl. monocikli.cpp)! A tagfüggvények mindegyike legyen inline megvalósítású, így kevesebbet kell gépelnie

Valósítsa meg a Jarmu és a Szan osztályt C++ nyelven úgy, hogy az adattagokat a konstruktorok a paramétereknek megfelelően inicializálják. (Vigyázzon, mindkét adattag privát!)
Ellenőrizze megoldását
```
class Jarmu {
    double vMax;
public:
    Jarmu(double v) :vMax(v) {}
};

class Szan : public Jarmu {
    int kutyakSzama;
public:
    Szan(double v = 0, int n = 0) :Jarmu(v), kutyakSzama(n) {}
};
```
Ezután egészítse ki az osztályokat az alábbiaknak megfelelően! Minden kiírást egy tabulátorjellel (\t) kezdjen!
- A Jarmu osztály konstruktora írja ki, hogy: \tJarmu ctor vMax=, majd ezt követően a vMax tagváltozó értékét, majd egy soremelést!
- A Szan osztály konstruktora írja ki, hogy: \tSzan ctor kutyakSzama=, majd ezt követően a kutyakSzama tagváltozó értékét, majd egy soremelést!
???
```
class Jarmu {
    double vMax;
public:
    Jarmu(double v) :vMax(v)    { std::cout << "\tJarmu ctor vMax=" << vMax << std::endl; }
};

class Szan : public Jarmu {
    int kutyakSzama;
public:
    Szan(double v = 0, int n = 0) :Jarmu(v), kutyakSzama(n)
                                { std::cout << "\tSzan ctor kutyakSzama=" << kutyakSzama << std::endl; }
};
```
Próbálja ki az alábbi főprogrammal a létrehozott osztályokat:
```
/// Utasítás kiíró és végrehajtó makró
#define _(x)  std::cout << #x << std::endl; x

int main() {
_(    Szan sz0_obj;             )
_(    Szan sz1_obj(1.1, 1);     )
_(    return 0;                 )
}
```
Ha mindent jól valósított meg, akkor a standard outputon az alábbi sorok jelennek meg:
```
Szan sz0_obj;
        Jarmu ctor vMax=0
        Szan ctor kutyakSzama=0
Szan sz1_obj(1.1, 1);
        jarmu ctor vMax=1.1
        Szan ctor kuytakSzama=1
return 0;
```
Vegye észre, hogy az alaposztály (Jarmu) adattagját (vMax) a főprogram egyfajta azonosítónak használja, azaz mindig olyan értéket kap, melynek egészrésze előfordul az objektum nevében! A kiírások elemzésénél ez később segítség lesz.

Bővítse az osztályokat destruktorral, melyek "\tJarmu dtor" ill. "\Szan dtor" szöveg után a konstruktorhoz hasonlóan írják ki a megfelelő adattagot is!

???

class Jarmu {
...
    ~Jarmu()                    { std::cout << "\tJarmu dtor vMax=" << vMax << std::endl; }
};
class Szan : public Jarmu {
...
    ~Szan()                     { std::cout << "\tSzan dtor kutyakSzama=" << kutyakSzama << std::endl; }
};

Ha mindent jól valósított meg, akkor standard outputon a következő 11 sor jelenik meg:

Szan sz0_obj;
        Jarmu ctor vMax=0
        Szan ctor kutyakSzama=0
Szan sz1_obj(1.1, 1);
        jarmu ctor vMax=1.1
        Szan ctor kutyakSZama=1
return 0;
        Szan dtor kutyakSZama=1
        Jarmu dtor vMAx=1.1
        Szan dtor kutyakSZama=0
        Jarmu dtor vMAx=0

Figyelje meg a konstruktorok/destruktorok hívási sorrendjét, és azt, hogy az alaposztály destruktorát nem kellett (nem is szabad) explicit meghívni Szan osztály destruktorából!

Módosítsa main függvényt úgy, hogy hívódjon meg Szan osztály másoló konstruktora is!

int main() {
_(    Szan sz0_obj;             )
_(    Szan sz1_obj(1.1, 1);     )
_(    Szan sz1m_obj = sz1_obj;  )
_(    return 0;                 )
}

Futtassa programot, majd bővítse a Jarmu osztályt másoló konstruktorral, ami kiírja, hogy \tJarmu copy, majd a szöveg után a konstruktorhoz hasonlóan írja ki a megfelelő adattagot is! Ügyeljen arra, hogy az adattag másolása is megtörténjen!
???
```
class Jarmu {
...
    Jarmu(const Jarmu& j) :vMax(j.vMax) 
                                { std::cout << "\tJarmu copy vMax=" << j.vMax << std::endl; }
};
```
Futtassa programot, majd bővítse a Szan osztályt is másoló konstruktorral, ami kiírja, hogy "\tSzan copy\n", majd a szöveg után a konstruktorhoz hasonlóan írja ki a megfelelő adattagot is! Ügyeljen arra, hogy az adattag és alaposztály másolása is megtörténjen!
???
```
class Szan : public Jarmu {
...
    Szan(const Szan& sz) :Jarmu(sz), kutyakSzama(sz.kutyakSzama) 
                                { std::cout << "\tSzan copy kutyakSzama=" << sz.kutyakSzama << std::endl; }
};
```
A destruktoroknál kiíródó adatok alapján ellenőrizze, hogy tényleg megtörtént-e a másolás! (2 db olyan objektumnak kell megszűnnie, melynek az adattagja nem nulla.) Ha mindent jól valósított meg, akkor standard outputon a következő kimenet jelenik meg:
```
Szan sz0_obj;
        Jarmu ctor vMax=0
        Szan ctor kutyakSzama=0
Szan sz1_obj(1.1, 1);
        Jarmu ctor vMax=1.1
        Szan ctor kutyakSzama=1
Szan sz1m_obj = sz1_obj;
        Jarmu copy vMax=1.1
        Szan copy kutyakSzama=1
return 0;
        Szan dtor kutyakSZama=1
        Jarmu dtor vMAx=1.1
        Szan dtor kutyakSZama=1
        Jarmu dtor vMAx=1.1
        Szan dtor kutyakSZama=0
        Jarmu dtor vMAx=0
```
Vegye észre, hogy az elkészített másoló konstruktor default konstruktort fog hívni, ha nem hívjuk meg az alap, vagy a beágyazott objektum másolóját explicit módon!

Módosítsa a főprogramot az alábbiak szerint, majd futtassa a kódot!

int main() {
#if 1
_(    Szan sz1_obj(1.1, 1);         )
#else
_(    Jarmu *jp = new Szan(2.2, 2); )
_(    delete jp;                    )
#endif
_(    return 0;                     )
}

Ellenőrizze, hogy minden objektum megszűnt-e, azaz minden objektumnak lefutott-e a destruktora!
Most írja át a feltételes fordítás feltételét, hogy az objektum a dinamikus memóriaterületen jöjjön létre, majd futtassa a kódot!

Minden objektum megszűnt? Mit kell tennie, hogy minden rendben megszűnjön? (Ötlet: delete jp; utasítás az alaposztály pointerén keresztül töröl! Most kellene a MANÓ!)

???

class Jarmu {
...
    virtual ~Jarmu() { std::cout << "Jarmu dtor vMax=" << vMax << std::endl;}
};

Ha mindent jól valósított meg, akkor standard outputon a következő 7 sor jelenik meg:

Jarmu *jp = new Szan(2.2, 2);
        Jarmu ctor vMAx=2.2
        Szan ctor kutyakSzama=2
delete jp;
        Szan dtor kutyakSzam=2
        Jarmu dtor vMAx=2.2
return 0;

A végleges kódrészlet így nézhet ki:

class Jarmu {
    double vMax;
public:
    Jarmu(double v) :vMax(v)    { std::cout << "\tJarmu ctor vMax=" << vMax << std::endl; }
    Jarmu(const Jarmu& j) :vMax(j.vMax)
                                { std::cout << "\tJarmu copy vMax=" << j.vMax << std::endl; }
    virtual ~Jarmu()            { std::cout << "\tJarmu dtor vMax=" << vMax << std::endl; }
};

class Szan : public Jarmu {
    int kutyakSzama;
public:
    Szan(double v = 0, int n = 0) :Jarmu(v), kutyakSzama(n)
                                { std::cout << "\tSzan ctor kutyakSzama=" << kutyakSzama << std::endl; }
    Szan(const Szan& sz) :Jarmu(sz), kutyakSzama(sz.kutyakSzama)
                                { std::cout << "\tSzan copy kutyakSzama=" << sz.kutyakSzama << std::endl; }
    ~Szan()                     { std::cout << "\tSzan dtor kutyakSzama=" << kutyakSzama << std::endl; }
};

3. Feladatcsoport (~10')

Egészítse ki a 2. feladatcsoport modelljét kerékpár (Bicikli) osztállyal. Használja fel az 1. feladatcsoport Kerek osztályát, amit úgy alakítson át, hogy az is alaposztállyá válhasson! Segítségül megadjuk a modell osztálydiagramját, melyben feltételezzük, hogy az első és hátsó kerék átmérője azonos. Az alapértelmezett tagfüggvényeket (paraméter nélküli konstruktor, copy konstruktor, destruktor, ...) általában nem szokták jelölni az osztálydiagramon, ezért mi sem jelöltük, azonban ügyeljen a megvalósításra.

Feladatok:

Töltse le az előkészített projektet (https://git.ik.bme.hu/Prog2/labor_peldak/lab_06 -> bicikli) a GIT tárolóból!
A bicikli.h fájlban valósítson meg minden szükséges osztály! Az osztályok tagfüggvényeit inline valósítsa meg!
Minden osztály konstruktora, másoló konstruktora és destruktora a fentieknek megfelelő formátumban és tartalommal írjon a standard kimenetre. (pl. "Bicikli ctor atmero=16", vagy "Szan ctor kutyakSzama=0")

Futtassa a bicikli_teszt0.cpp tesztprogramot! Ha mindent jól valósított meg, akkor standard outputon a következő kimenet jelenik meg:

	Jarmu ctor vMax=1.1
	Szan ctor kutyakSzama=7
	Jarmu copy vMax=1.1
	Szan copy kutyakSzama=7
	Jarmu ctor vMax=10
	Kerek ctor
	Kerek ctor
	Bicikli ctor atmero=16
	Jarmu copy vMax=10
	Kerek copy
	Kerek copy
	Bicikli copy atmero=16
	Kerek ctor
	MyKerek ctor atmero=-1
	MyKerek dtor atmero=-1
	Kerek dtor
	Jarmu ctor vMax=0
	Kerek ctor
	Kerek ctor
	Bicikli ctor atmero=0
	Bicikli dtor atmero=0
	Kerek dtor
	Kerek dtor
	Jarmu dtor vMax=0
	Bicikli dtor atmero=16
	Kerek dtor
	Kerek dtor
	Jarmu dtor vMax=10
	Bicikli dtor atmero=16
	Kerek dtor
	Kerek dtor
	Jarmu dtor vMax=10
	Szan dtor kutyakSzama=7
	Jarmu dtor vMax=1.1
	Szan dtor kutyakSzama=7
	Jarmu dtor vMax=1.1

Ha elégedett az eredménnyel, akkor töltse fel az elkészített bicikli.h fájlt a Jporta rendszerbe (6. labor önellenőrző feladat), hogy megkapja a labor elvégzéséért járó pontot!
A Jpota tesztprogramja a standard outputra történő kiírásokat egy stringstream objektumba irányítja, és úgy elemzi. Ha szorgalmi jelleggel érdeklik a részletek, a feladat feltöltésekor lekérdezheti magát a tesztpogramot is. A tesztprogram frodításához C++11-es beállítás szükséges.

Jó munkát!

Utolsó frissítés: 2024-01-31 18.19

Keresés űrlap

Útmutató a 6. laborhoz

Ellenőrző kérdések:

Laborfeladatok megoldásokkal

1. feladatcsoport. (~35')

Feladatok:

2. feladatcsoport. (~35')

Feladatok:

3. Feladatcsoport (~10')

Feladatok:

Főmenü