Útmutató a 7.5 laborhoz

A laborfeladat az előadások és a laborok közötti csúszást hivatott kiegyenlíteni. Erre utal a 7.5 elnevezés.

Laborfeladatok megoldásokkal

A feladat célja az osztályokkal, örökléssel, a virtuális tagfüggvényekkel, valamint a heterogén kollekciókkal kapcsolatos ismeretek elmélyítése. A feladat a 7. laborfeladat síkidomokat modellező példáját bővíti tovább. A megoldás során fel kell használni a 7. laborfoglalkozáson elkészített Rajztabla osztályt.
A laborfoglalkozás végén 5 db fájlt kell feltöltenie — nagy részük már majdnem kész van — a Jporta rendszerbe (7.5 önellenőrző feladat), hogy megkapja a labor elvégzéséért járó pontot! Legalább az első öt tesztesetet (ELEKESZULT >= 5) hibátlanul meg kell oldania! A feladatok feltöltésére a laborgyakorlatot követő szombat 06:00-ig van lehetősége.

1. Töltse le a laborgyakorlathoz előkészített projektet: https://git.ik.bme.hu/Prog2/labor_peldak/lab_07.5, ami a 7. laboralkalommal már megismert síkidomokat modellező példa módosított változata. Kezdetben a modell csak szakaszt, kört és rajztáblát tartalmaz, amit később bővíteni fogunk. Az új osztályok és funkciók kipróbálását a főprogramban definiált ELKESZULT makróval lehet vezérelni. A megértést segíti a mellékelt osztálydiagram:
   
   
2. Első feladatként a modellt egy Poligon osztállyal bővítjük. A poligon első csúcsát és színét a konstruktorban kell megadni. Követelmény továbbá, hogy a poligonnak legyen
   • size() tagfüggvénye, amivel lekérdezhető, hogy hány csúcspontja van,
   • add() tagfüggvénye, amivel újabb pontot lehet adni a poligonhoz,
   • rajzol() tagfüggvénye, ami "kirajzolja" a poligont, azaz kiírja az adatait,
   • operator[]() tagfüggvénye, amivel lekérdezhető egy adott csúcspont.

   Legyen továbbá olyan globális insertere, amivel kiírathatók a poligon adatai a szakasznál és a háromszögnél is alkalmazott formához hasonlóan. Mivel a poligonnak tetszőleges számú csúcspontja lehet, a pontokat dinamikus memóriában fogjuk tárolni. A poligon.h fájlban elkészítettük az osztály deklarációját, ami még nem végleges. A dinamikus memóriaterület közvetlen használata miatt az implicit másoló konstruktor és értékadó operátor nem használható ezért ezeket is meg kell valósítani.
   Egészítse ki a poligon.h és poligon.cc fájlokat úgy, hogy az osztály az elvárásoknak megfelelően működjön! Megoldását több lépcsőben tesztelheti az ELKESZULT makró segítségével:

   • == 1 - Van Poligon osztály, amit önmagában kipróbál, de copy és assign még nincs használva;
   • >= 2 - Poligon assign-t is teszteli
   • >= 3 - Poligon assign-t és copy-t is teszteli
A másoló konstruktor és az értékadás megvalósításakor ne felejtse el az alaposztály megfelelő tagfüggvényeit is meghívni, hogy az alaposztály adattagjai is inicializálódjanak. Ne módosítsa az alakzat.h fájlt!
Célszerű a másoló konstruktor megvalósítását visszavezetni az értékadó operátorra! Fordítva is lehetséges, de a memtrace nem tudja kezelni a placement new-t, ezért most ezt ne próbálja ki!



poligon.h

/**
 *  \file poligon.h
 *  Poligon osztály deklarációja
 */
#ifndef POLIGON_H
#define POLIGON_H
#include "alakzat.h"
/// Poligon osztály
/// dinamikusan tárolja a csúcspontokat
class Poligon : public Alakzat {
    Pont *pontok;       ///< csúcspontok tárolója
    size_t np;          ///< ennyi csúcsból áll
public:
    /// Konstruktor
    /// @param p0 - kezdőpont
    /// @param sz - szín és átlátszóság
    Poligon(const Pont& p0, const Szin sz) :Alakzat(p0, sz), np(1)
           { pontok = new Pont[np-1]; } // eggyel kevesebbet foglal, mert a p0 az alaposztályban van

    /// Copy konstruktor
    /// @param rhs - ezt másoljuk le
    Poligon(const Poligon& rhs) :Alakzat(rhs.getp0(), rhs.getsz()) {
        pontok = NULL;
        *this = rhs;
    }

    /// Ertekadó operátor
    /// @param rhs - ezt másoljuk le
    /// @return önmaga
    Poligon& operator=(const Poligon& rhs);

    /// Csúcspontok darabszámának lekérdezése
    /// @return darab
    size_t size() const { return np; }

    /// Adott csúcspont koordinátájának lekérdezése
    /// Nem létező csp. esetén kivételt dob
    /// @param i - i. csúcspont lekérdezése
    /// @return adott csúcspont koordinátai
    Pont operator[](size_t i) const;

    /// Új csúcspont felvétele
    /// @param p - új csúcspont koordinátai
    void add(const Pont& p);

    /// Poligont rajzol
    void rajzol() const;

    ~Poligon() { delete[] pontok; }
};
/// Globális << operátor
std::ostream& operator<<(std::ostream&, const Poligon&);
#endif // POLIGON_H






poligon.cpp

/**
 *  \file poligon.cpp
 *  Poligon osztály tagfüggvényinek megvalósítása
 */
#include "poligon.h"

Poligon& Poligon::operator=(const Poligon& rhs) {
    if (this != &rhs) {
        Alakzat::operator=(rhs);
        delete[] pontok;
        np = rhs.np;
        pontok = new Pont[np-1]; // eggyel kevesebbet foglal, mert a p0 az alaposztályban van
        for (size_t i = 0; i < np-1; i++)
            pontok[i] = rhs.pontok[i];
    }
    return *this;
}

Pont Poligon::operator[](size_t i) const {
    if (i >= np) throw "Poligon: nincs ilyen csucspont!";
    if (i == 0) return getp0();
    return pontok[i-1] + getp0();   // p0-hoz relatívan tárolunk
}

void Poligon::add(const Pont& p) {
    Pont *tp = new Pont[np];
    for (size_t i = 0; i < np-1; i++)
        tp[i] = pontok[i];
    delete[] pontok;
    pontok = tp;
    pontok[np-1] = p - getp0();     // kezdőponthoz relatívan tárolunk
    ++np;
}

void Poligon::rajzol() const {
    std::cout << "Rajzol: " << *this << std::endl;
}

std::ostream& operator<<(std::ostream& os, const Poligon& k) {
    os << "Poligon " << (Alakzat&)k << ",csp=" << k.size();
    for (size_t i = 1; i < k.size(); ++i)
       os << ",p" << i << "=" << k[i];
    return os;
}

3. A 7. laboralkalommal elkészítette a Rajztabla osztályt. Emelje át megoldását ebbe a projektbe (rajztabla.h, rajztabla,cpp)! Fordítson és teszteljen! A keretprogram ELKESZULT==4 értéknél poligon nélkül fut, ELKESZULT==5 értéknél pedig poligonnal.
4. A programunkban dinamikus memóriaterületen hozunk létre az alakzatokat, amelyekre pointerrel hivatkozunk. Ha egy pointerrel hivatkozott objektumról másolatot szeretnénk készíteni a dinamikus memóriában, akkor meg kell hívnunk a másoló konstruktorát valahogy így:
   

   	Szakasz*  pEredeti = new Szakasz(Pont(20,40), 100, 0, WHITE);
   	Szakasz*  pMasolat = new Szakasz(*pEredeti);
   

   Tegyük fel, hogy át szeretnénk másolni egy rajztábla objektumot egy másik rajztáblába. Ekkor nem elegendő a tárolt pointerek lemásolása, a benne tárolt alakzatokról is kell egy-egy másolat (deep copy), ahogy a poligon pontjait is le kellett másolnunk az első feladatban. Igen ám, de a rajztábla objektum alaposztályra mutató pointereket tárol, ezért nem tudjuk, hogy melyik alakzat másoló konstruktorát kell meghívni. Most lenne jó egy virtuális konstruktor, amit a ZH-ban többen fel szoktak találni, de sajnos a C++ nyelvben ilyen nincs. Helyette azonban bevezethetünk egy tagfüggvényt (pl. clone), ami már lehet virtuális és létrehoz egy másolatot saját magából a dinamikus memóriában. A clone használatával már egyszerű a másolat elkészítése. pl:

   	Alakzat*  pEredeti = new Szakasz(Pont(20,40), 100, 0, WHITE);
   	Alakzat*  pMasolat = pEredeti->clone();
   

   Módosítsa az alakzat.h fájt úgy, hogy legyen az Alakzat osztálynak egy tisztán virtuális konstans Alakzat* clone() tagfüggvénye is!
   

   
   

   ???

   /// alakzat.h
   /// ...
   virtual Alakzat* clone() = 0;
   

5. Valósítsa meg a Szakasz osztály clone() tagfüggvényét a zzakasz.h fájlban! Állítsa az ELKESZULT makró értékét 6-ra! Fortdítson, teszteljen!
   
   
   

   ???

   /// szakasz.h 
   /// ....
   Szakasz* clone() { return new Szakasz(*this); }
   

6. Valósítsa meg a rajztábla értékadó operátorát és a másoló konstruktorát a clone() függvény felhasználásával! Állítsa az ELKESZULT makró értékét 7-re! Fortdítson, teszteljen!
   
   Célszerű a másoló konstruktor megvalósítását visszavezetni az értékadó operátorra! Fordítva is lehetséges, de a memtrace nem tudja kezelni a placement new-t, ezért most ezt ne próbálja ki!
   
   

   ???

   Rajztabla& Rajztabla::operator=(const Rajztabla& rhs) {
       if (this != &rhs) {
           torol();
   		db = rhs.db;
           for (size_t i = 0; i < db; i++)
               tabla[i] = rhs.tabla[i]->clone();
       }
       return *this;
   }
   
   Rajztabla::Rajztabla(const Rajztabla& rhs) {
       db = 0;
       *this = rhs;
   }

7. Legyen a poligon is klónozható! Állítsa az ELKESZULT makró értékét 8-ra! Fortdítson, teszteljen!
8. Ha elégedett az eredménnyel, akkor töltse fel az elkészített illetve módosított poligon.h, poligon.cpp, szakasz.h, rajztabla.h, rajztabla.cpp fájlokat a Jporta rendszerbe (7.5 labor önellenőrző feladat), hogy megkapja a labor elvégzéséért járó pontot! Legalább ELKESZULT==5 szintig el kell jutnia.
   Amennyiben további feladatokat is megoldott, úgy feltöltés előtt a poligon.h fájlban definiálja a ELEKSZULT makrót!
   Hogy ne legyen gond a többszörös deifinicióból a lokális környezetében, célszerűen a definiciós rész így nézzen ki:

   #ifndef POLIGON_H
   #define POLIGON_H
   
   #undef ELKESZULT
   #define ELKESZULT   7  // A legnagyobb érték, amit szeretne, hogy a jporta teszteljen. 
   ...
   

9. Valósítsa meg a Rajztabla osztályt a 7. előadáson bemutatott generikus tömb fixArray felhasználásával (https://git.ik.bme.hu/Prog2/eloadas_peldak/ea_07 gen_array2)! Ezt a tárolót a C tömbökkel azonos módon lehet indexelni, ezért a Rajztabla osztály deklarációjában és implementációjában csupán néhány sor változik:
   • Include-olni kell a sablont tartalmazó fájlt (gen_array2.hpp).
   • Változik a tabla tagváltozó deklarációja.

   A gen_array2.hpp fájlt már hozzáadtuk a projekthez, csak használnia kell! Megoldásának teszteléséhez állítsa az ELKESZULT makró értékét 9-re!

   
   

   ???

   ...
   #include "gen_array2.hpp"           /// generikus osztály 
   
   /// Rajztabla osztály
   class Rajztabla  {
       static const size_t MAXDB = 100;
       Array<Alakzat*, MAXDB> tabla;   ///< tároló deklarációja 
       size_t db;                      ///< aktuális darabszám
   ...
   

Jó munkát!

Szeberényi Imre