Gyakorló feladatok (3. hét)

Fontosabb kulcsszavak, fogalmak

• new, delete, iostream, kivételkezelés felülnézetben
• OO paradigmák, azok közül is legfőképp az egységbezárás
• C megvalósítás, this
• tagfüggvények, kívül és belül definiált tagfüggvények
• konstans tagfüggvények
• konstruktorok, destruktor
• operátor overload

Javasolt gyakorló feladat

1. Az előadáson bemutatott Komplex osztály mintájára készítsünk egy racionális számokat tároló osztályt!
2. Kérdések a tervezéshez:
   • Hogyan írható le a feladat absztrakt adattal?
   • Hogyan reprezentálható maga az adat?
   • Hogyan viselkedik? Milyen műveletei vannak?
   • Hogyan szeretnénk használni?
     Pl így:

     int main() {
         Racionalis r, r1(3), r2(1,2), r3(1,3), rt[100];
         std::cout << r3.getSzamlalo() << std::endl;
         r1.kiir();
         r = r1 + r2;
         r = r1 * r2;
         r = !r2;
     }
     

   • Deklaráljuk osztályt!
     Az adatot és a rajta műveletet végző függvényeket összezárjuk. Minden ami belső ügy az a külvilág felé elérhetetlen. Ez jó, mert szabadon változtatható a belső.
     
     
     

     ???

     class Racionalis {
         int szamlalo;
         int nevezo;
     public:
         Racionalis(int sz = 0, int n = 1);
         Racionalis operator+(Racionalis r) const;
         Racionalis operator*(Racionalis r) const;
         Racionalis operator!() const;              // szám reciproka  
         int getSzamlalo() const { return szamlalo; }
         int getNevezo() const { return nevezo; }
         void kiir(std::ostream& os = std::cout) const;
         void setSzamlalo(int sz);
         void setNevezo(int n);
     };
     

   • Ezután valósítsuk meg a tagfüggvényeket!
     
     
     

     ???

     
     Racionalis::Racionalis(int sz, int n) {
         szamlalo = sz;
         nevezo = n;
     }
     
     Racionalis Racionalis::operator+(Racionalis r) const {
         int sz = szamlalo * r.nevezo + r.szamlalo * nevezo;
         int n = nevezo * r.nevezo;
         return Racionalis(sz, n);
     }
     
     Racionalis Racionalis::operator*(Racionalis r) const {
         int sz = szamlalo * r.szamlalo;
         int n = nevezo * r.nevezo;
         return Racionalis(sz, n);
     }
     
     Racionalis Racionalis::operator!() const {
         return Racionalis(nevezo, szamlalo);
     }
     
     void Racionalis::kiir(std::ostream& os) const {
         os << szamlalo << "/" << nevezo;
     }
     
     

   • Bővítse a főprogramot kis dinamikus játékkal, majd válaszoljon az alábbi kérdésekre:
     

        Racionalis *rp = new Racionalis(1,2);
        rp->kiir();
        delete rp;
        Racionalis *rpt = new Racionalis[20];
        rpt[0].kiir();
        delete[] rpt;
        rp = &r;
     

     • Mit ír ki?
     • Mikor hányszor fut le a konstruktor? Melyik?
     • Mikor hányszor fut le a destruktor?
     • A címképzéshez nem írtunk tagfüggvényt. Mégis lehet használni?
     • Mi történne, ha most kiadnánk egy delete rp-t?
   • Láttuk, hogy a printf, scanf nem biztonságos, gonosz függvények. Törtünk saját felelőssége jól kiírni magát. A függvény overload segítségével ezt a tudást a globális inserter operátorra bízhatjuk. Készítse el azt az insertert!
     
     
     

     ???

     std::ostream& operator<<(std::ostream &os, const Racionalis &r) {
         r.kiir(os);
         return os;
     }
     

   • Készítsen beolvasó függvényt is!
     
     
     

     ???

     std::istream& operator>>(std::istream& is, Tort& t) {
         int sz, n;
         is  >> sz;
         is.ignore(5, '/');  // max. 5 karaktert eldobunk '/' végjelig. Nem bolondbiztos megoldás!
         is >> n;
         t.setSzamlalo(sz);
         t.setNevezo(n);
         return is;
     }