Jövő órán kiszh lesz.

Órai feladat

Készítsünk komplex osztályt.

• Készítsünk kiíró tagfüggvényt,
• valósítsuk meg az összeadás és a hozzáadás műveletét tagfüggvényekkel,
• valósítsuk meg a fenti két műveletet operátor túlterheléssel (+ illetve +=),
• ahol csak lehet, használjunk referenciát, ami lehet, az legyen const.

Feltétlenül szükséges-e, hogy a két tagváltozó privát elérésű legyen? Most nem, mert mindkettő tetszőleges valós értéket felvehet, egymástól függetlenül (nem tudjuk elrontani).

5. Házi feladat.

1. Egészítsük ki a komplex osztályt.
   • Az egyszerűbb elérés érdekében mindenképpen tegyük pulikus elérésűvé a tagváltozókat,
   • valósítsuk meg a kétféle szorzás műveletet operátor túlterheléssel. (Komplex * Komplex, Komplex *= Komplex) Az operátorok tagfüggvények legyenek.
   • valósítsuk meg a kétféle kivonás műveletet operátor túlterheléssel. (Komplex − Komplex, Komplex −= Komplex) Az operátorok osztályon kívüli függvények legyenek (pl. a tesztelő elején). Ugye most nincs this, ellenben két paraméter van,
   • kell-e külön operátorfüggvényt írnunk a Komplex + double típusú összeadáshoz? próbáljuk ki a tesztelőben! (ha van egy darab double értéket fogadó ctor-a az osztálynak, akkor a jobboldali operandus automatikus típuskonverzión esik át, ezért nem kell külön függvény)
   • ügyeljünk, hogy a *= és a −= operátor láncolható legyen (pl. a = b −= c)
   • valósítsunk meg az egyoperandusú ~ és − operátorok egyikét tagfüggvényként, a másikat osztályon kívüliként. Előbbi az operandus komplex konjugáltját (re−imj), utóbbi a −1-szeresét (−re−imj) kell visszaadja,
   • ahol csak lehet, használjunk referenciát, ami lehet, az legyen const!
2. Készítsünk racionális osztályt.
   • Most lehet-e public a nevező? nem, mert nem szabad 0 értéket kapnia. akkor viszont legyen a számláló is private (szimmetria).
   • valósítsuk meg a négy alapműveletet túlterhelt operátorokkal. (Rac op. Rac) Az operátorok tagfüggvények legyenek, másként sok get... kellene bele.
   • valósítsuk meg a fenti műveletek op.= alakját.
   • valósítsuk meg egy unáris (egyoperandusú) reciprokképző operátort: ~
   • Inicializáláskor a törtet meg lehessen adni nulla vagy egy paraméterrel is (a nevező legyen 1).
   • Készítsük el a Print, DiagPrint és a Rac2dbl függvényeket.
   • Valósítsunk meg néhány további operátort, az alábbi main szerint szükségeseket. Az == vizsgálónak tilos valós értékeket hasonlítani (miért is?), de pl. 6/8 == 9/12 igazat kell adjon!
   • talán érdemesebb inkább mindig az egyszerűsített alakot tárolni. Legyen egy primitív egyszerűsítő tagfüggvény, ami minden műveletvégzéskor automatikusan hívódik (azaz az operátorfüggvények, ctor, stb. hívják meg az eredmény szolgáltatása előtt.) ez lehet private tagfüggvény, hisz a programból nem kell hívogatni...
   • A program tagolása a szokásos: 3 file.
   • ahol csak lehet, használjunk referenciát, ami lehet, az legyen const!
   • Kipróbáló modul (csak a jelzett helyen szúrhatsz be újabb sorokat, mást ne változtass!):

     #include <iostream> //stdio.h helyett
     #include "Rac.h"
     
     int main()
     {
         Rac a(6,8);
         Rac b = Rac(3,4); // igy is lehet
         Rac c(1);         // 1
         Rac d;            // 0
         DiagPrint(a);     // NEM tagfv.    ki: 6 / 8 vagy. 3 / 4
         b.Print();        // ki: 3 / 4
         DiagPrint(c);     // ki: 1 / 1
         std::cout << b.Rac2dbl() << '\n'; // == printf("%f\n",b.Rac2dbl())   ki: 0.75
         c=b*b;
         DiagPrint(c);     // ki: 9 / 16
         c/=3;             // ez egy Rac operator/=(int) fv
         DiagPrint(c);     // ki: 3 / 16
         c/=b;             // ez egy Rac operator/=(Rac) fv, NEM azonos az elozovel
         DiagPrint(c);     // ki: 1 / 4, vagy bovitett alakja
         c.operator /=(b); // igy is lehet hivni, de nem igy szoktuk
         DiagPrint(c);     // ki: 1 / 3, vagy bovitett alakja
         std::cout << (a==b ? "azonos\n" : "kulonbozo\n");  // ki: azonos. NE valos ertekeket hasonlitsunk.
         c/=(b); 
         DiagPrint(~c);    // ki: 9 / 4, vagy ...
         DiagPrint(c);     // ki: 4 / 9, vagy ...
                           //ide meg tehetsz kodot tovabbi operatoraid tesztelesehez
         return 0;
     }