Gyakorló feladatok (9. hét)

Fontosabb kulcsszavak, fogalmak

• Többszörös öröklés
• Perzisztencia
• Generikus szerkezetek
• Perzisztencia megvalósítása (többszörös) örökléssel

Feladatok megoldásokkal

1. Korábbi Komplex osztályunkból készítsünk egy perzisztens viselkedésű osztályt (PKomplex)! Az egyszerűség kedvéért a Komplex osztály műveleteit hagyjuk el, csak a setter/getter tagfüggvényeket valósítsuk meg!
   

   class Komplex {
       double re;
       double im;
   public:
       Komplex(double _re = 0, double _im = 0) :re(_re), im(_im) {}
       void setRe(double _re) { re = _re; }
       void setIm(double _im) { im = _im; }
       double getRe() const { return re; }
       double getIm() const { return im; }
   };
   

   A perzisztens működés megvalósításához alkalmazzuk az előadáson látott módszert, ahol a Serializable osztály read és write tagfüggvényeit valósítottuk úgy, hogy azok ki tudják írni és be tudják olvasni az objektum állapotát.

   struct Serializable {
       virtual std::ostream& write(std::ostream&) const = 0;
       virtual std::istream& read(std::istream&) = 0;
       virtual ~Serializable() {};
   };
   

   A PKomplex osztály adatait szöveges formátumban írjuk ki! A kiírások elválasztására használjunk szeparátort (SEP), hogy jól látható legyen az egyes kiírások határa.
   

   
   

   ???

   #define SEP std::endl // így jobban követhető, de érdemes kipróbálni nem whitespace-szel is!
   
   struct PKomplex : Komplex, Serializable {
       PKomplex(double re = 0, double im = 0) :Komplex(re, im) {}
       std::ostream& write(std::ostream& os) const {
           os << getRe() << "j " << getIm(); // j-vel olvashatóbb
           return os << SEP;           // szeparátor a komplex adat után
       }
       std::istream& read(std::istream& is) {
           double re, im;
           (is >> re).ignore(1) >> im; // valós és képzetes r. beolvasása
           setRe(re);
           setIm(im);
           return is.ignore(1);        // a komplex adat utáni szeparátor eldobása
   
       }
   };
   

2. Nézzük meg a PKomplex osztály használatát! Ezzel a megoldással az objektumok állapota akár a hálózaton is átküldhető lenne. Mit ír ki a következő programrészlet?
   

       std::stringstream s;
   
       PKomplex pk(8,9), pk_vissza;
       pk.write(s);
       pk_vissza.write(cout);
       pk_vissza.read(s);
       pk_vissza.write(cout);
   

3. Helyes-e ill. működik-e az alábbi kódrészlet?
   

       Komplex k;
       k = pk;
       pk = k;
   

4. A k = pk a kompatibilitás miatt működik, de fordítva nem. Oldjuk meg a konverziót!
   
   
   

   ???

   struct PKomplex : Komplex, Serializable {
    ...
     PKomplex(const Komplex& k) :Komplex(k) {}
    ...
   };

5. A Komplex példán keresztül láttuk, hogy már létező osztályból többszörös örökléssel tudunk perzisztens változatot készíteni. Új osztályokat szükség esetén eleve perzisztens viselkedésűre tervezünk. Készítsünk perzisztens viselkedésű 3 elemű egész vektort (PIntVec)! A vektor legyen indexelhető, de ne ellenőrizze az indexhatárokat! A méretet statikus konstansként kezeljük. Így könnyű lesz változtatni. A konstruktor nullázza ki a vektor elemeit! Az osztály származzon a Serializable osztályból, és valósítsa meg annak read és write metódusait!
   
   
   

   ???

   class PIntVec : public Serializable {
       static const int siz = 3;
       int vec[siz];
   public:
       PIntVec() { for (int i = 0; i < siz; i++) vec[i] = 0; }
       int& operator[](int i) { return vec[i]; }
       const int& operator[](int i) const { return vec[i]; }
       std::ostream& write(std::ostream& os) const {
           os << "PIntVec: " << siz << SEP;  // szeparátort írunk az méret után
           for (int i = 0; i < siz; i++)
               os << vec[i] << SEP;          // szeparátort írunk az elemek után
           return os;
       }
       std::istream& read(std::istream& is) {
           std::string s;
           int size;
           if (is >> s && s == "PIntVec:" && is >> size && size == siz) {
               is.ignore(1);                 // méret utáni szeparátor eldobása
               for (int i = 0; i < siz; i++)
                   (is >> vec[i]).ignore(1); // beolvasás és a szeparátor eldobása
           } else throw std::out_of_range("Rossz adat");
           return is;
       }
   };
   

6. Próbáljuk ki az alábbi kódrészlettel:
   

       std::stringstream s;
   
       PIntVec piv, piv_vissza;
       for (int i = 0; i < 3; i++) piv[i] = i;
       piv.write(s);
       piv_vissza.write(cout);
       piv_vissza.read(s);
       piv_vissza.write(cout);
   

7. Általánosítsuk a vektorunkat! Készítsünk belőle olyan sablont (PVec), aminek sablonparaméterként megadható a mérete!
   
   
   

   ???

   template <class T, int siz = 10>
   class PVec : public Serializable {
       T vec[siz];
   public:
       PVec() { for (int i = 0; i < siz; i++) vec[i] = T(); }
       T& operator[](int i) { return vec[i]; }
       const T& operator[](int i) const { return vec[i]; }
       std::ostream& write(std::ostream& os) const {
           os << "PVec: " << siz << SEP;     // szeparátort írunk a méret után
           for (int i = 0; i < siz; i++)
               os << vec[i] << SEP;          // szeparátort írunk az elemek után
           return os;
       }
       std::istream& read(std::istream& is) {
           std::string s;
           int size;
           if (is >> s && s == "PVec:" && is >> size && size == siz) {
               is.ignore(1);                 // méret utáni szeparátor eldobása
               for (int i = 0; i < siz; i++)
                   (is >> vec[i]).ignore(1); // beolvasás és a szeparátor eldobása
           } else throw std::out_of_range("Rossz adat");
           return is;
       }
   };
   

8. Próbáljuk ki a sablonunkat!
   

       PVec<double, 4> pdv, pdv_vissza;
       for (int i = 0; i < 4; i++) pdv[i] = i+0.1;
       pdv.write(s);
       pdv_vissza.write(cout);
       pdv_vissza.read(s);
       pdv_vissza.write(cout);
   

9. Működik a PKomplex osztállyal is?
   

       PVec<PKomplex, 5> pkv, pkv_vissza;
       pkv[1] = pk;
       pkv.write(s);
       pkv_vissza.write(cout);
       pkv_vissza.read(s);
       pkv_vissza.write(cout);
   

10. Az a baj, hogy a PVec inserter-t és extractor-t használ. Ilyen függvény viszont nincs PKomplex osztályhoz. Oldjuk meg a problémát!
    
    
    

    ???

    Készítsünk két globális függvényt:

    std::ostream& operator<<(std::ostream& os, Serializable const& obj) {
        obj.write(os);
        return os;
    }
    std::istream& operator>>(std::istream& is, Serializable& obj) {
        obj.read(is);
        return is;
    }
    

    Így minden Serializabe osztályból származó osztályhoz lett inserter és extrator, ami .write és .read tagfüggvényekre vezet vissza. Ebből persze adott esetben származhatnak kellemetlenségek is.