Útmutató a 3. laborhoz

A laborgyakorlaton egyszerű osztályokat hozunk létre a 3. heti előadás anyagához kapcsolódóan. A bemelegítő példát (Téglalap) követően az előadáson bemutatott Komplex osztályt építjük fel lépésenként. Az elkészített osztály működését a már megismert a gtest_lite keretrendszerrel felépített tesztprogrammal ellenőrizzük.

Felkészülés a laborra

1. Nézze át a 3. előadás anyagát, és példaanyagát!
2. Ismételje át a 2. heti laborgyakorlat anyagát!
3. Oldja meg a Jporta NEM_OO feladatát!

Laborfeladatok megoldásokkal

• Töltse le a 3. laborhoz előkészített projektet a tantárgy Git tárolójából https://git.ik.bme.hu/Prog2/labor_peldak/lab_03! A labor anyaga több katalógusba van szervezve. Fájlkezelővel ellenőrizze, hogy mi töltődött le! Sikeres letöltés esetén 2 db katalógust (Teglalap, Komplex) kell látnia.
• Gyakorló feladat (megoldására tervezett idő max. 10 perc)!
  Ne feledje, hogy a tagfüggvények az objektum adatát közvetlenül elérik, ezért nincs paramétere sem a kerület, sem a terület tagfüggvénynek!
  1. A Teglalap könyvtárban levő teglalap.cpp fájlban egy nagyon egyszerű osztály (Teglalap) deklarációja, valamint az osztályt példányosító főprogram található. Az Ön feladata a hiányzó tagfüggvények elkészítése. Az osztály teszteléséhez a főprogram néhány objektumpéldányt hoz létre és azokkal meghívja a tagfüggvényeket. Az ELKESZULT makróval vezérelhető, hogy csak a már elkészült tagfüggvényeket hívja meg a főprogram.
  2. Elemezze az előkészített programot, majd készítse el a hiányzó függvényeket. Fordítsa le a programot és futtassa!

"Komplex" feladat továbbfejlesztése

A továbbiakban az előadáson bemutatott Komplex osztályt kell kiegészítenie. A Komplex alkatalógusban előkészítettük a munkához szükséges fájlokat:

komplex.h

Komplex osztály deklarációja.

komplex.cpp

Komplex osztály tagfüggvényinek definíciója (megvalósítása).

elkeszult.h

A teszteseteket engedélyező ELKESZULT makró definíciója.

komplex_teszt.cpp

KomplexAz osztályból példányosított objektumok helyes működését ellenőrző egyszerű tesztprogram.

gtest_lite.h

Google gtest csomagjához hasonló, de lényegesen szerényebb teszteszköz

Feladatok
A laborfoglalkozás végén ne felejtse el feltölteni megoldásait a Jporta rendszerbe, hogy megkapja a labor elvégzéséért járó pontot! Az alábbi feladatokból legalább az első négy feladatot hibátlanul meg kell oldania! A feladatok feltöltésére a laborgyakorlatot követő szombat 06:00-ig van lehetősége.

Ha projektfájlra kattintva nem indul a CodeBlocks, indítsa azt el, majd húzza rá a megnyíló ablak fejlécére a projektfájlt!
1. Nyissa meg az előkészített CodeBlocks vagy Visual C++ projektet a megfelelő projektfájl segítségével!
2. Elemezze (a kommenteket is olvassa el) a projekthez tartozó állományokat! A teszteseteket a korábban megismert gtest_lite makrók segítségével alakítottuk ki. Nézzük példaként a konstruktorok létezését és a paraméter nélkül hívható konstruktor helyes működését ellenőrző tesztesetet:
   

   // Konstruktorok létezésének és a paraméter nélküli konstruktor működésének tesztje
     TEST(Komplex000, Letezik) {    // Testeset neve: Komplex000, a teszt neve: Letezik  
       Komplex k, k1(1), k2(1,2);   // Ezek az objektumok a teszteset lokális objektumai. 
                                    // Ha nincs fordítási hiba akkor az objektumok létrejöttek.  
       EXPECT_EQ(0, k.getRe());     // Megvizsgáljuk, hogy a paraméter nélküli konstruktor 0-val inicializál-e.
       EXPECT_EQ(0, k.getIm());     // Ha nem, akkor baj van
    } END << "Hiba esetén még ez a szöveg is kiíródik" << endl; 
   

   Minden testesetet elkészítettünk. Önnek csupán a Komplex osztály megfelelő tagfüggvényeit kell elkészítenie.

3. Első feladatként valósítsa meg a konstans objektumra is alkalmazható getRe() és getIm() metódusokat a komplex.cpp állományban! Emlékezzen rá, hogy konstans objektumra csak olyan tagfüggvény alkalmazható, ami nem változtatja az objektum állapotát (const tagfüggvény). Ilyen szerepelt az előző (Teglalap) feladatban is, illetve az előre elkészített abs() tagfüggvény is ilyen.
   A korábbi feladatokhoz hasonlóan az ELKESZULT makróval szabályozhatja, hogy a tesztprogram mely tagfüggvényeket tesztelje. A get... metódusok teszteléséhez állítsa az EKLESZULT értékét 1-re az elkeszult.h fájlban, majd fordítsa és futtassa a programot!
   Célszerű a komplex.h fájl megfelelő sorait átmásolni a komplex.cpp-be, és azt módosítva megvalósítani a függvényeket. Ügyeljen arra, hogy a kívül definiált tagfüggvények előtt helyesen használja a scope operátort!
   
   

   Ha elakadna, nézze meg a megoldást!

   // komplex.cpp
   ...
   // TODO: A hiányzó tag- és globális függvények itt következnek
   
   #if ELKESZULT >= 1
   // Konstansra is alkalmazható lekérdező függvények
   /// Valós rész lekérdezése
   /// @return - valós rész
   double Komplex::getRe() const { return re; }
   
   .....
   #endif
   

Gyakran előfordul, hogy a fejlesztés során egy korábban már kipróbált, jónak ítélt kódrészlet „elromlik”. Ezért nagyon fontos, hogy a fejlesztés során a kód minden részét (egységét) folyamatosan újra és újra teszteljük még akkor is, ha azt már hibátlannak gondoljuk. Az itt bemutatott gtest_lite rendszer az egységtesztelés alapelveit kívánja bemutatni. A kidolgozott makrók és osztályok működésének megértése most még nem cél, de a félév végére minden világossá válik.
A keretrendszer megvalósításánál igyekeztünk kompatibilis megoldást találni a Google által fejlesztett és több Google projektben is alkalmazott gtest egységtesztelő (Unit Test) keretrendszerrel. Az ehhez hasonló Unit Test rendszereket gyakran úgy alkalmaznak nagy projektekben, hogy a projekt verziókezelő rendszere csak akkor enged új változatot betölteni, ha előtte a unit tesztek hibátlanul lefutottak.
4. A komplex.h állományban a feladatoknak megfelelő sorrendben deklaráltuk a továbbiakban elkészítendő függvényeket. Figyelje meg, hogy azoknál a függvényeknél, ahol paraméterként csak értéket kellene átadni (Komplex), ott hatékonysági okokból konstans referenciát adunk át! A Komplex osztálynak ugyan nincs nagy adatterülete, így csak néhány byte verembe másolását spóroljuk meg, de érdemes "rászokni" a konstans referenciára ilyen esetekben.
5. Készítse el valós és képzetes rész beállítására szolgáló beállító függvényeket(setRe(double), setIm(double))! Fordítson, teszteljen (ELKESZULT=2)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 2
   // beállító függvények
   /// Valós részt beállító függvény
   /// @param r - valós rész
   void Komplex::setRe(double re) { this->re = re;}
   
   /// Képzetes részt beállító függvény
   /// @param im - képzetes rész
   void Komplex::setIm(double im) { this->im = im;}
   #endif
   

6. Készítse el az egyenlőségvizsgáló (== ) operátort! A != operátort már elkészítettük, ami az == -re vezeti vissza a feladatot. Fordítson, teszteljen (ELKESZULT=3)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 3
   // összehasonlítás
   /// Egyenlőség vizsgálat
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return true - ha a képzetes és a valós rész is azonos, egyébként false
   bool Komplex::operator==(const Komplex& rhs_k) const {
       return re == rhs_k.re && im == rhs_k.im;
   }
   #endif
   

Komplex számokat komponensenként adunk össze..
7. Készítse el a + (összeadás) operátorokat! Működjön a komplex összeadás valós számokkal is (először csak jobbról) Fordítson, teszteljen (ELKESZULT=4)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 4
   // összeadás, a + nem módosítja önmagát ezért konstans fv.
   /// Komplex + Komplex
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return egy új komplex adat - a két komplex adat összege
   Komplex Komplex::operator+(const Komplex& rhs_k) const {
       return Komplex(re+rhs_k.re, im+rhs_k.im);
   }
   
   /// Komplex + double
   /// @param rhs_k - jobb oldali operandus (double)
   /// @return egy új komplex adat - a két adat összege
   Komplex Komplex::operator+(double rhs_d) const {
       return *this + Komplex(rhs_d, 0);
   }
   #endif
   

A globális függvény közvetlenül nem fér hozzá a privát adattagokhoz!
8. Készítsen összeadó operátort, ami alkalmas valós + komplex összeadására! Ebben az esetben a bal oldali operandus nem objektum, így globális operátorfüggvénnyel kell megvalósítani a feladatot. Fordítson, teszteljen (ELKESZULT=5)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 5
   // double + Komplex csak globális függvénnyel valósítható meg,
   // mivel a bal oldal nem osztály
   /// double + Komplex
   /// @param lhs_d - bal oldali operandus (double)
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return egy új komplex adat - a két adat összege
   Komplex operator+(double lhs_d, const Komplex& rhs_k) {
       return rhs_k + lhs_d;
   }
   #endif
   

9. Készítsen += operátort! (A valós változatot már előre elkészítettük.) Fordítson, teszteljen (ELKESZULT=6)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 6
   // a += művelet viszont módosítja önmagát!
   /// Komplex + Komplex
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return eredeti (bal oldali) objektum, amihez hozzáadtuk rhd_k-t
   Komplex& Komplex::operator+=(const Komplex& rhs_k) {
       return *this = *this + rhs_k;
   }
   #endif
   

Szorgalmi feladatok:

A kért kiírási formátumban a képzetes rész előtt ki kell írni a képzetes rész előjelét (a pozitívat is), de a valós rész előtt csak a negatív előjel jelenjen meg! (tipp: showpos, noshowpos, ignore, iomanip)
1. Legyen kiírható a komplex adat egy ostream típusú objektumra a << operátorral 1+34j ill. 1-34j alakban!
   Be lehessen olvasni egy istream típusú objektumból a >> operatorral ugyanilyen 1+34j alakban! Fordítson, teszteljen (ELKESZULT=7)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 7
   // cout << Komplex is csak globális függvénnyel valósítható meg, mivel
   // az baloldali osztály (ostream) nincs a kezünkben, nem módosítható
   /// Kiíáras egy ostream-re
   /// @param os - bal oldali operandus (ostream)
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return ostream, hogy fűzhető legyen
   std::ostream& operator<<(std::ostream& os, const Komplex& rhs_k) {
       std::ios_base::fmtflags ofmt = os.flags(); // régi flag elmentése
       os << std::noshowpos << rhs_k.getRe() << std::showpos << rhs_k.getIm() << 'j';
       os.flags(ofmt);   // flag visszaállítása
       return os;
   }
   
   /// Beolvasás egy istream-ről
   /// @param is - bal oldali operandus (istream)
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return itsream, hogy fűzhető legyen
   std::istream& operator>>(std::istream& is, Komplex& rhs_k) {
       double re, im;
       is >> re >> im; // beolvasunk
       rhs_k = Komplex(re, im);
       is.ignore(1);   // nagyon bízink benne, hogy ott a 'j'
       return is;
   }
   #endif
   

Komplex szám konjugáltja: a-bj..
2. Valósítsa meg a ~ operátort, amely a Komplex konjugáltját képzi! Fordítson, teszteljen (ELKESZULT=8)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 8
   Komplex Komplex::operator~() const {
       return Komplex(re, -im);
   }
   #endif
   

Komplex számokat algebrai alakban a következő formulával szorzunk:
(a+bj)·(c+dj) = (ac-bd) + (ad+bc)j.
a+bj.
3. Készítsen *= operátort. Működjön valóssal (double) is!
   Legyen * operátora is az osztálynak! Működjön valóssal balról és jobbról is! Fordítson, teszteljen (ELKESZULT=9)!
   
   
   

   ???

   // komplex.cpp-be
   #if ELKESZULT >= 9
   // szorzás, a * nem módosítja önmagát ezért konstans fv.
   /// Komplex * Komplex
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return egy új komplex adat - a két komplex adat szorzata
   Komplex Komplex::operator*(const Komplex& rhs_k) const {
       return Komplex(re*rhs_k.re - im*rhs_k.im, re*rhs_k.im + im*rhs_k.re);
   }
   
   /// Komplex * double
   /// @param rhs_d - jobb oldali operandus (double)
   /// @return egy új komplex adat - a két adat szorzata
   Komplex Komplex::operator*(double rhs_d) const {
       return *this * Komplex(rhs_d);
   }
   
   /// double * Komplex csak globális függvénnyel valósítható meg,
   /// mivel a bal oldal nem osztály
   Komplex operator*(double lhs_d, const Komplex& rhs_k) {
       return rhs_k * lhs_d;
   }
   
   // a *= művelet viszont módosítja önmagát!
   /// Komplex * Komplex
   /// @param rhs_k - jobb oldali operandus (Komplex)
   /// @return eredeti (bal oldali) objektum ref., amit megszorosztunk
   Komplex& Komplex::operator*=(const Komplex& rhs_k) {
       return *this = *this * rhs_k;
   }
   
   /// Komplex *= double
   /// @param rhs_d - jobb oldali operandus (double)
   /// @return eredeti (bal oldali) objektum ref., amit megszoroztunk
   Komplex& Komplex::operator*=(double rhs_d) {
       return *this = *this * Komplex(rhs_d);
   }
   #endif
   

Jó munkát!