Útmutató a 11. laborhoz

Felkészülés a laborra

• Ismételje át a többszörös öröklésről és a perzisztenciáról tanultakat (9. előadás anyaga)!
• Ajánlott megcsinálni a Clonable Hetero feladatot!

A laborgyakorlat az ún. rombusz vagy diamond öröklés problémáját, valamint egy összetettebb perzisztencia megvalósítást mutat be konkrét példákon keresztül.

Feladatok megoldásokkal

Az ún. rombusz v. diamond öröklés problémájának elemzése (~30')

0. Töltse le az előkészített fájlokat https://git.ik.bme.hu/Prog2/labor_peldak/lab_11, majd nyissa meg a diamond alkatalógusban található projektet! Röviden elemezze a tesztprogramot (diamond_test.cpp)! A palkalmazott.h és a perz_test.cpp állományok elemzését és megértését hagyhatja későbbre!) Vegye észre:
   • Az elkeszult állományban definiált ELKESZULT makró értékétől függően egyre több teszteset hajtódik végre.
   • ELKESZULT >=2 értékek tesztesetei a perz_test.cpp állományban vannak megvalósítva.
   • Egyes tesztesetek csak a képernyőre írnak, de van olyan is, ami gtest_lite ellenőrző funkcióit használja és a kiírásokat úgy ellenőrzi, hogy a standard output helyett egy std::stringstream típusú adatfolyamba irányítja az írást, majd az adatfolyam std::string "arcát" felhasználva hasonlít az elvárt kimenethez.
   • ELKESZULT <= 1 esetben az Alkalmazott alaposztály (alkalmazott.h) konstruktora minden lefutáskor egy nagy 'A' betűt ír ki, a destruktor pedig kiírja, hogy "megszunik".

   Állítsa az ELKESZULT makró értékét 0-ra, majd fordítson és futtasson! A mintaprogram futtatásával meggyőződhet arról, hogy az Alkalmazott osztály adattagjai megduplázódtak a HatIdCsV ill. HatIdCsVezH objektumokban. Különösen feltűnő ez a fizetéseknél, amit szándékosan eltérő értékkel inicializáltunk:

   AAAAAAA
   Lusta Dick fizetese: 100
   HatIdeju: Grabovszki fizetese: 300
   CsopVez: Mr. Gatto  fizetese: 500
   HatIdCsv:
      CsopVez: Mr. Tejfel fizetese: 1200
      HatIdeju: Mr. Tejfel fizetese: 6000
   HatIdCsVezH: HatIdCsv:
      CsopVez: Safranek fizetese: 1400
      HatIdeju: Safranek fizetese: 7000
   Megszunik: Lusta Dick fizetese: 100
   Megszunik: Grabovszki fizetese: 300
   Megszunik: Mr. Gatto  fizetese: 500
   Megszunik: Mr. Tejfel fizetese: 6000
   Megszunik: Mr. Tejfel fizetese: 1200
   Megszunik: Safranek fizetese: 7000
   Megszunik: Safranek fizetese: 1400
   

   • Figyelje meg, hogy az első sorban 7 db A betű jelent meg, ami azt jelenti, hogy 7-szer hívódott meg az Alkalmazott konstruktora, holott 5 db objektumot (Alkalmazott, HatIdeju, CsopVez, HatIdCsV, és HatIdCsVezH) hoztunk létre a tesztprogramban.
   • Magyarázza meg, hogy miért kell a típuskonverzió a main függvény azon soránál, ahol a HatIdCsV és a HatIdCsVezH típusú objektumokat akarunk a tárolóba tenni! Akkor is kell, ha virtuális öröklést használunk?
   • Figyelje meg, hogy az Alkalmazott destruktorából hívott kiir() sosem a származtatott osztály kiir() függvénye! Miért?
Az üresen hagyott helyek segítenek!
1. Elődadáson is látta, hogy a többszöröződéseket az okozza, hogy az Alkalmazott alaposztály adattagjai két öröklési útvonalon is beépülnek a HatIdCsV osztályba. Ezzel szemben virtuális öröklés során az adattagok pointereken keresztül épülnek be, így azok az öröklési láncon összeérve azonos adattagra mutatnak.
   Módosítsa az irodistak.h fájlt úgy, hogy a HatIdeju és a CsopVez osztályok virtuális örökléssel jöjjenek létre az Alkalmazott osztályból! Ne felejtse el az Alkalmazott alaposztály megfelelő konstruktorát meghívni az öröklési lánc végén! Ha elfelejti, akkor a default konstruktor hívódik!
   
   
   

   ???

   ....
   class CsopVez : virtual public Alkalmazott {
   ...
   class HatIdeju : virtual public Alkalmazott {
   ...
       HatIdCsV(const char* n, double f, csop_t cs, time_t t)
           :Alkalmazott(n, f),     // Alkalmazott konstruktor
            CsopVez(n, f*2, cs),   // szándékosan más fizetést kap,
            HatIdeju(n, f*10, t)   // hogy látható legyen az adatduplikáció
       {}
   ...
       HatIdCsVezH(CsopVez& kit, const char* n, double f, time_t t)
           :Alkalmazott(n, f),     // Alkalmazott konstruktor
            HatIdCsV(n, f, kit.cs(), t) // alaposztály
       {}
   ...
   

   
   Állítsa az elkeszult.h fájlban definiált ELKESZULT makró értékét 1-re, majd fordítson és futtasson! Figyelje meg, hogy mi változott! Ha mindent jól módosított, akkor az alábbi kimenetet kell kapnia:

   AAAAA
   Lusta Dick fizetese: 100
   HatIdeju: Grabovszki fizetese: 300
   CsopVez: Mr. Gatto  fizetese: 500
   HatIdCsv:
      CsopVez: Mr. Tejfel fizetese: 600
      HatIdeju: Mr. Tejfel fizetese: 600
   HatIdCsVezH: HatIdCsv:
      CsopVez: Safranek fizetese: 700
      HatIdeju: Safranek fizetese: 700
   Megszunik: Lusta Dick fizetese: 100
   Megszunik: Grabovszki fizetese: 300
   Megszunik: Mr. Gatto  fizetese: 500
   Megszunik: Mr. Tejfel fizetese: 600
   Megszunik: Safranek fizetese: 700
   

2. Elemezze az Iroda osztály megvalósítását az iroda.h fájlban! A tarolo_tipus-t azért vezettük be, hogy a tároló könnyen lecserélhető legyen bármilyen standard tárolóra. Figyelje meg, hogy az iterátor használatával nem korlátozódott indexelhető tárolókra a megoldás!

   Cserélje le az std::vector-t először std::list-re, majd std::deque-ra! Ne felejtse el a megfelelő header fájlt include-olni! Fordítsa le, majd futtassa az alkalmazást!

Perzisztens viselkedés megvalósítása (~45')

3. Egészítse ki a fenti feladatot úgy, hogy az irodisták állapota elmenthető és visszaállítható legyen! A 9. előadáson látottak alapján több lehetősége is van:
   • Többszörös öröklést alkalmazva hozza létre a perzisztens változatot. Ekkor az eredeti osztályt nem kell módosítani.
   • Módosítja az osztályokat a perzisztens viselkedés kialakítása érdekében.

   Az első megoldás tisztább, és ez a javasolt megoldás. Esetünkben külön figyelmet igényel a virtuális alaposztály konstruktorainak hívása, de ez nem egy megterhelő feladat. (Az öröklési láncok végén a virt. alaposztály megfelelő konstruktora hívódjon meg.)
   Alkalmazott osztály perzisztens változatát előre elkészítettük az első megoldásnak megfelelően a palkalmazott.h fájlban. Elemezze a megoldást, majd állítsa ELKESZULT makró értékét 2-re az elkeszult.h fájlban! Fordítson, futtasson!

4. Készítse el a pirodistak.h fájlban a többi irodai alkalmazott perzisztens osztályát! Lépésenként haladva teszteljen a ELKESZULT makró segítségével (CsopVez = 3, HatIdeju = 4, Hat IdejuCsv = 5, HatIdejuCsVez = 6)!
   
   
   

   ???

   /**
    * \file pirodistak.h
    * Minden származtatott osztály deklarációját ebbe a fájlba tettük.
    * Az egyszerűség kedvéért minden tagfüggvényt inline valósítottunk meg.
    *
    */
   #ifndef PIRODISTAK_H
   #define PIRODISTAK_H
   
   #include <stdexcept>
   #include "palkalmazott.h"
   #include "irodistak.h"
   
   /**
    * Perzisztens csoportvezető
    */
   struct PCsopVez : public CsopVez, public Serializable {
       PCsopVez(const std::string& n, double f, csop_t cs)
           : Alkalmazott(n, f),    /// öröklési lánc végén explicit meg kell hívni
             CsopVez(n, f, cs) {}
       /// konverzió miatt kell
       PCsopVez(const CsopVez& csv) : Alkalmazott(csv), CsopVez(csv) {}
   
       void write(std::ostream& os) const {
           os << "PCsopVez" << std::endl;
           PAlkalmazott(*this).write(os);  /// kihasználjuk, hogy kompatibilis
           os << getCs() << std::endl;
       }
   
       void read(std::istream& is) {
           std::string tmp;
           (is >> tmp).ignore(1);
           if (tmp != "PCsopVez")          /// ellenőrizzük, hogy mit olvasunk
               throw std::out_of_range("PCsopvez_R "+tmp);
           PAlkalmazott pa("",0);          /// ebbe olvasunk
           pa.read(is);
           *((Alkalmazott*)this) = pa;     /// kompatibilitás miatt
           csop_t cs;
           (is >> cs).ignore(1);           /// csoport beolvasása
           setCs(cs);
       }
   };
   
   /**
    * Perzisztens Határozott idejű alkalmazott
    */
   struct PHatIdeju : public HatIdeju, public Serializable {
       PHatIdeju(const std::string& n, double f, time_t t)
           : Alkalmazott(n, f),        /// öröklési lánc végén explicit meg kell hívni
             HatIdeju(n, f, t) {}
       /// konverzió miatt kell
       PHatIdeju(const HatIdeju& hati) : Alkalmazott(hati), HatIdeju(hati) {}
   
       void write(std::ostream& os) const {
           os << "PHatIdeju" << std::endl;
           PAlkalmazott(*this).write(os);  /// kihasználjuk, hogy kompatibilis
           os << getIdo() << std::endl;
       }
   
       void read(std::istream& is) {
           std::string tmp;
           (is >> tmp).ignore(1);
           if (tmp != "PHatIdeju")     /// ellenőrizzük, hogy mit olvasunk
               throw std::out_of_range("PHatIdeju_R "+tmp);
           PAlkalmazott pa("",0);      /// ebbe olvasunk
           pa.read(is);
           *((Alkalmazott*)this) = pa; /// kompatibilitás miatt
           time_t t;
           (is >> t).ignore(1);        /// idő beolvasása
           setIdo(t);
       }
   };
   
   /**
    * Perzisztens Határozott idejű csoportvezető
    */
   struct PHatIdCsV :public HatIdCsV, public Serializable {
       PHatIdCsV(const std::string& n, double f, csop_t cs, time_t t)
           : Alkalmazott(n, f),        /// öröklési lánc végén explicit meg kell hívni
             HatIdCsV(n, f, cs, t) {}
   
       PHatIdCsV(const HatIdCsV& haticsv) : Alkalmazott(haticsv), HatIdCsV(haticsv) {}
   
       void write(std::ostream& os) const {
           os << "PHatIdCsV" << std::endl;
           PCsopVez(*this).write(os);  /// kihasználjuk, hogy kompatibilis
           os << getIdo() << std::endl;
       }
   
       void read(std::istream& is) {
           std::string tmp;
           (is >> tmp).ignore(1);
           if (tmp != "PHatIdCsV")     /// ellenőrizzük, hogy mit olvasunk
               throw std::out_of_range("PHatIdCsV_R "+tmp);
           PCsopVez pcs("", 0, 0);     /// ebbe olvasunk
           pcs.read(is);
           *((CsopVez*)this) = pcs;    /// kompatibilitás miatt
           time_t t;
           (is >> t).ignore(1);        /// idő beolvasása
           setIdo(t);
       }
   };
   
   /**
    * Perzisztens Határozott idejű csoportvezető helyettes
    */
   class PHatIdCsVezH :public HatIdCsVezH, public Serializable {
   public:
       PHatIdCsVezH(const  std::string& n, double f, time_t t, HatIdCsV& kit)
           : Alkalmazott(n, f),        /// öröklési lánc végén explicit meg kell hívni
             HatIdCsVezH(n, f, t, kit) {}
   
       PHatIdCsVezH(const HatIdCsVezH& h) : Alkalmazott(h), HatIdCsVezH(h) {}
   
       void write(std::ostream& os) const {
           os << "PHatIdCsVezH" << std::endl;  /// kihasználjuk, hogy kompatibilis
           PHatIdCsV(*this).write(os);
       }
   
       void read(std::istream& is) {
           std::string tmp;
           (is >> tmp).ignore(1);
           if (tmp != "PHatIdCsVezH")      /// ellenőrizzük, hogy mit olvasunk
               throw std::out_of_range("PHatIdCsVezH: read");
           PHatIdCsV phcs("", 0, 0, 0);    /// ebbe olvasunk
           phcs.read(is);
           *((HatIdCsV*)this) = phcs;     /// kompatibilitás miatt
       }
   };
   #endif // PIRODISTAK_H
   

5. IMSC feladat: Az Iroda osztály egy heterogén tároló. A "benne levő" objektumok perzisztensek. Hogyan lehetne az egész tárolót perzisztens viselkedésűvé tenni? A kiírással nincs gond, de a visszatöltés?
   
   Kiíráskor ki kell írni valamilyen azonosítót, ami alapján visszaolvasáskor létre lehet hozni a megfelelő osztályt. OK, de hogyan lehet ezt könnyen bővíthetően megoldani? Az nem lenne túl szép, ha a tároló kódjába előre be kellene kódolni, hogy milyen objektumokat tárol!
   
   

   Ötlet

   1. A heterogén kollekció minden osztálya adjon vissza egy egyedi azonosítót. Erre a célra pont megfelel a typeid operátor, ami a típusra/osztályra jellemző egyedi információt (type_info) ad.
      Ennek egyik mezője (name) egy egyedi név (std::string).
   2. A tároló az objektumok tárolásakor, vagy az inicializálási fázisban (ld. később) kérdezze le ezt a nevet, és a névhez tárolja le az objektum címét pl. egy map-ben.
   3. Amikor a tároló adatfolyamba írja (sorosítja) az objektumokat, akkor minden objektum kiírása előtt írja ki az osztályra jellemző egyedi nevet. Ennek alapján visszaolvasáskor létrehozható a megfelelő objektum.
   4. De egy üres tárolóban nem lesznek címek. Mit lehet tenni? Ezt a map-et statikusan kell létrehozni. Így minden, még az üres tároló is látja, ha egyszer létrejött.
   5. OK, de mi van, ha most indul a program, ami a diszkről akarja felolvasni az adatokat? Legalább egyszer be kell tenni minden osztályból egy példányt a tárolóba, azaz kell egy regisztrációs fázis, ráadásul biztosítani kell, hogy a "regisztrált" objektumok ne szűnjenek meg. Ezért célszerű a regisztrációt/inicializálást és a használatot kettéválasztani valahogy így:

       PHeteroStore<Alkalmazott> pmunkahely;  /// perzisztens viselkedésű heterogén tároló
   
       /// Regisztrációs fázis. Ekkor minden objektumból egy példányt beteszünk egy statikus táblába.
       pmunkahely.registerCtor(new PAlkalmazott);
       pmunkahely.registerCtor(new PCsopVez);
       pmunkahely.registerCtor(new HatIdCsV);
   ...
   
       pmunkahely.felvesz(new Alkalmazott("Lusta Dick", 100);
       pmunkahely.felvesz(new HatIdeju("Grabovszki", 300, 1000));
   ...
   
       pmunkahely.write(....);
       PHeteroStore<Alkalmazott> masikmunkahely; 
       masikmunkahely.read(....);
   
   

6. IMSC feladat: A fenti ötletek, valamint a korábban elkészített Clonable Hetero feladat alapján készítsen perzisztens viselkedésű, másolható generikus heterogén tárolót!
   
   
   

   ???

   //
   // file: phetero_store.hpp
   //
   #ifndef PHETERO_STORE_HPP
   #define PHETERO_STORE_HPP
   
   #include <stdexcept>
   #include <vector>
   #include <typeinfo>
   #include <map>
   #include <string>
   #include "serializable.h"
   
   template <typename T>
   struct PHeteroStore : public Serializable  {
       std::vector<T*> store;                    ///< itt tároljuk az obj. pointereket
       /// Belső osztály a statikus tárolóhoz
       struct Ctors {
           typedef std::map<std::string, T*> maptype;
           maptype ct;                           ///< itt tároljuk az (azonosító, pointer párokat)
           
           /// egyszerűen akarjuk elérni az elemeket
           T*& operator[](std::string id) { return ct[id]; }
           
           /// megszűnéskor az objektumokat is törölni kell 
           ~Ctors() {
               for (typename maptype::iterator it = ct.begin(); it != ct.end(); ++it)
                   delete it->second;
           }
       };
       /// Csak egyetlen statikus példányt hozunk létre
       static Ctors ctors;               
   public:
       /// iteratorok 
       typedef typename std::vector<T*>::const_iterator const_iterator;
       const_iterator begin() const { return store.begin(); }
       const_iterator end() const { return store.end(); }
   
       /// konstruktor
       PHeteroStore() {}
   
       /// másolót visszavezetjük a értékadásra
       PHeteroStore(const PHeteroStore& st) {
           *this = st;
       }
   
       /// size
       size_t size() const { return store.size(); }
   
       /// Ezzel regisztráljuk a perzistens működéshez az objektumokat
       void registerCtor(T* o) {
           ctors[typeid(*o).name()] = o;     // eltesszük a példányt
       }
   
       /// add
       void add(T* o) {
           try {
              store.push_back(o);
           } catch (std::bad_alloc) {
               delete o;
               throw;
           }
       }
   
       /// értékadás klónoz 
       PHeteroStore& operator=(const PHeteroStore& st) {
           if (this != &st) {
               clear();
               for (const_iterator it = st.begin(); it != st.end(); ++it)
                   add((*it)->clone());
           }
           return *this;
       }
   
       /// adatfolyamba írás
       void write(std::ostream& os) const {
           os << "PHeteroStore_size: " << store.size() << std::endl;
           for (const_iterator it = store.begin(); it != store.end(); ++it) {
               os << typeid(**it).name() << std::endl; /// kiírjuk az egyedi azonosítót
               (*it)->write(os);                       /// és megkérjük, hogy írja ki magát
           }
       }
   
       /// adatfolyamból olvasás
       void read(std::istream& is) {
           clear();
           std::string tmp;
           std::getline(is, tmp, ':');
           if (tmp != "PHeteroStore_size") throw std::out_of_range("Hibas input");
           size_t siz;
           (is >> siz).ignore(2, '\n');        /// meg van a méret
           for (size_t i = 0; i < siz; ++i) {
               std::getline(is, tmp);          /// beolvassuk az egyedi azonosítót
               T *o = ctors[tmp]->clone();     /// legyártjuk az objektumot 
               o->read(is);                    /// saját magát már be tudja olvasni
               add(o);
           }
       }
   
       /// clear 
       void clear() {
           for (const_iterator it = store.begin(); it != store.end(); ++it)
               delete *it;
           store.clear();
       }
   
       /// destruktor
       virtual ~PHeteroStore() { clear(); }
   };
   
   /// statikus adattagot létre kell hozni
   template<typename T>
   typename PHeteroStore<T>::Ctors PHeteroStore<T>::ctors;
   
   #endif // PHETERO_STORE_HPP
   
   

7. Extra:
   A what alkatalógusban található programok rejtett programozási hibákra próbálják felhívni a figyelmet.
   • A secret nevű program az előadáson is mutatott Buffer Overflow hibát demonstrálja.
   • A hello_world nevű program az úgynevezett Use After Free hiba, viszonylag könnyen elkövethető változatát mutatja be.
   • A badguy nevű program szintén a Use After Free hibát demonstrálja kicsit komplikáltabb helyzetben.

   A témához kapcsolódó érdekes olvasmány: https://alexgaynor.net/2019/apr/21/modern-c++-wont-save-us/

Jó munkát!

Szeberényi Imre