1. Zßklady OOP I
  1. Nßsledujφcφ p°φklad ukazuje pou╛itφ z°et∞zenΘho seznamu vytvo°enΘho objektov∞ orientovan²m zp∙sobem.

    2. class okno {
      int delka;
      int sirka;
      okno *dalsi_okno;
    public:
      okno(void);
      void nastav(int nova_delka, int nova_sirka);
      int ziskej_plochu(void);
      void nastav_ukazatel(okno *ktere_okno);
      okno *ziskej_dalsi(void);
    };
    okno::okno(void){
      delka = 8;
      sirka = 8;
      dalsi_okno = NULL;
    }
    void okno::nastav(int nova_delka, int nova_sirka){
      delka = nova_delka;
      sirka = nova_sirka;
    }
    int okno::ziskej_plochu(void){
      return (delka * sirka);
    }
    void okno::nastav_ukazatel(okno *ktere_okno){
      dalsi_okno = ktere_okno;
    }
    okno *okno::ziskej_dalsi(void){
      return dalsi_okno;
    }
    int main(int argc, char **argv)
    {
      okno *start = NULL;                                        // V╛dy ukazuje na poΦßtek seznamu
      okno *temp;                                                    // Pracovnφ ukazatel
      okno *ukazatel_na_okno;                               // Pou╛ito pro vytvß°enφ okna
      for (int index = 0; index < 10; index++){         // Generovßnφ seznamu
        ukazatel_na_okno = new okno;
        ukazatel_na_okno->nastav(index + 1, index + 3);
        if (start == NULL)
          start = ukazatel_na_okno;                         // Prvnφ prvek v seznamu
        else
          temp->nastav_ukazatel(ukazatel_na_okno);         // dal╣φ prvek
        temp = ukazatel_na_okno;
      }
      temp = start;                                                   // V²pis seznamu
      do {
        cout << "Plocha okna je " << temp->ziskej_plochu() << endl;
        temp = temp->ziskej_dalsi();
      } while (temp != NULL);
      temp = start;                                                   // Zru╣enφ seznamu
      do {
        temp = temp->ziskej_dalsi();
        delete start;
        start = temp;
      } while (temp != NULL);
      return 0;
    }
    Tento program vytvß°φ z°et∞zen² seznam 10 objekt∙, vypφ╣e plochy t∞chto objekt∙ a seznam zru╣φ. Zjist∞te jak tento program pracuje.
  2. Zm∞≥te p°edchozφ program tak, aby z°et∞zen² seznam obsahoval 1000000 prvk∙. P°idejte takΘ test k zji╣t∞nφ, zda ka╛dß dynamickß alokace byla provedena. Zajist∞te, aby v²stup obsahoval sprßvnΘ hodnoty.
  3. Dal╣φ program pou╛φvß t°φdu vno°enou do t°φdy. Jednß se o velmi jednoduch² p°φklad. Program obsahuje t°φdu okno, kterß byla znaΦn∞ zjednodu╣ena a jako jedna slo╛ka je do nφ vlo╛ena t°φda, kterou jsme nazvali podtrida. Tento objekt je pro pou╛itφ p°φstupn² pouze v implementaci t°φdy okno, proto╛e je zde takΘ definovßn a ╛ßdnß jeho definice se nevyskytuje v hlavφm programu.

    4. class podtrida {
      int hodnota1;
      int hodnota2;
    public:
      void nastav(int h1, int h2){ hodnota1 = h1; hodnota2 = h2;}
      int ziskej_h2(void) {return hodnota2;}
    };
    class okno {
      int delka;
      int sirka;
      podtrida vn_trida;
    public:
      void nastav(int d, int s, int h1, int h2){
        delka = d;
        sirka = s;
        vn_trida.nastav(h1, h2);
      }
      int ziskej_plochu(void) {return(delka * sirka);}
    };
    int main(int argc, char **argv)
    {
      okno male, stredni, velke;
      male.nastav(2, 4, 1, 35);
      stredni. nastav(5, 6, 2, 72);
      velke.nastav(8, 10, 4, 98);
      cout << "Plocha malΘho okna je " << male.ziskej_plochu() << endl;
      cout << "Plocha st°ednφho okna je " << stredni.ziskej_plochu() << endl;
      cout << "Plocha velkΘho okna je " << velke.ziskej_plochu() << endl;
    }
    Prostudujte si tento program a p°idejte do n∞j p°φkazy, kterΘ vypφ╣φ i hodnoty ulo╛enΘ ve vno°enΘ t°φd∞ (bude-li pot°eba, vytvo°te i novΘ metody).
  4. Nßsledujφcφ program ukazuje p°ekr²vßnφ operßtor∙. To umo╛≥uje definovat objekty t°φdy a redefinovat normßlnφ operßtory. V²sledkem je, ╛e objekty novΘ t°φdy mohou b²t pou╛φvßny p°irozen∞ jako p°eddefinovanΘ typy.

    5. class okno {
      int delka;
      int sirka;
    public:
      void nastav(int nova_delka, int nova_sirka);
      int ziskej_plochu(void) {return(delka * sirka);}
      friend okno operator+(okno a, okno b); // SouΦet dvou oken vedle sebe
      friend okno operator+(int a, okno b);  // P°iΦtenφ konstanty k ╣φ°ce okna
      friend okno operator*(int a, okno b);  // Vynßsobenφ okna konstantou
    };
    void okno::nastav(int nova_delka, int nova_sirka){
      delka = nova_delka;
      sirka = nova_sirka;
    }
    okno operator+(okno a, okno b){
      okno pomocne;
      pomocne.delka = a.delka;
      pomocne.sirka = a.sirka + b.sirka;
      return pomocne;
    }
    okno operator+(int a, okno b){
      okno pomocne;
      pomocne.delka = b.delka;
      pomocne.sirka = a + b.sirka;
      return pomocne;
    }
    okno operator*(int a, okno b){
      okno pomocne;
      pomocne.delka = a * b.delka;
      pomocne.sirka = a * b.sirka;
      return pomocne;
    }
    int main(int argc, char **argv)
    {
      okno male, stredni, velke;
      okno pomocne;
      male.nastav(2, 4);
      stredni.nastav(5, 6);
      velke.nastav(8, 10);
      cout << "Plocha malΘho okna je " << male.ziskej_plochu() << endl;
      cout << "Plocha st°ednφho okna je " << stredni.ziskej_plochu() << endl;
      cout << "Plocha velkΘho okna je " << velke.ziskej_plochu() << endl;
      pomocne = male + stredni;
      cout << "Plocha novΘho okna je " << pomocne.ziskej_plochu() << endl;
      pomocne = 10 + male;
      cout << "Plocha novΘho okna je " << pomocne.ziskej_plochu() << endl;
      pomocne = 4 * velke;
      cout << "Plocha novΘho okna je " << pomocne.ziskej_plochu() << endl;
      return 0;
    }
    V na╣em programu jsou p°ekryty operßtory + a *. Jejich implementaΦnφ metody jsou deklarovßny jako sp°ßtelenΘ funkce (pomocφ klφΦovΘho slova friend). Jestli╛e nepou╛ijeme ?p°ßtelskou konstrukci, pak funkce musφ b²t Φßstφ jednoho objektu a tomuto objektu budeme zasφlat zprßvy. Pou╛itφ ?p°ßtelskΘ konstrukce umo╛≥uje odd∞lit tyto metody od objektu a volat je pomocφ infixovΘho zßpisu. Pomocφ tΘto techniky, m∙╛ou? konstrukci, objekt1 + objekt2 namφsto objekt1.operator+(objekt2). Bez p°ßtelskΘ konstrukce bychom takΘ nemohli p°ekr²t operßtory, kterΘ majφ jako prvnφ parametr (operand) typ int, nebo╗ nelze zaslat zprßvu celoΦφselnΘ prom∞nnΘ. Dva ze t°φ p°ekryt²ch operßtor∙ pou╛φvajφ int pro prvnφ parametr a je tedy nutno je deklarovat jako sp°ßtelenΘ funkce.
    ╚erven² °ßdek ukazuje prvnφ p°ekrytφ, kdy je p°ekr²vßn operßtor +. Zapisujeme nßvratov² typ nßsledovan² klφΦov²m slovem operator s operßtorem, kter² p°ekr²vßme. V zßvorkßch jsou uvedeny dva formßlnφ parametry a jejich typy a na nßsledujφcφch °ßdcφch pokraΦuje implementace funkce. Prvnφ parametr urΦuje lev² operand p°ekr²vanΘho operßtoru a druh² prav² operand. Na modrΘm °ßdku na╣eho programu je tato metoda volßna pomocφ infixovΘho zßpisu namφsto obvyklΘho formßtu zasφlßnφ zprßv. Jeliko╛ prom∞nnΘ male a strednφ jsou objekty t°φdy okno, systΘm hledß operßtor + pro dva objekty t°φdy okno a nalezne nß╣ prvnφ p°ekryt² operßtor. Dal╣φ p°ekrytΘ operßtory pou╛φvajφ jako lev² operand hodnotu typu int. Jinak pracujφ obdobn∞. Vyzkou╣ejte tento program. Zm∞≥te t°etφ °ßdek od konce na
    pomocne = velke * 4;
    a zjist∞te reakci na tuto zm∞nu.
  5. Dal╣φ program ukazuje p°ekr²vßnφ funkcφ ve t°φd∞. V tomto programu je pro ilustraci p°ekr²vßn konstruktor a jedna metoda.

    6. class mnoho_jmen {
      int delka;
      int sirka;
    public:
      mnoho_jmen(void);
      mnoho_jmen(int del);
      mnoho_jmen(int del, int sir);
      void zobraz(void);
      void zobraz(int jeden);
      void zobraz(int jeden, int dva);
      void zobraz(float cislo);
    };
    mnoho_jmen::mnoho_jmen(void) {
      delka = 8;
      sirka = 8;
    }
    mnoho_jmen::mnoho_jmen(int del) {
      delka = del;
      sirka = 8;
    }
    mnoho_jmen::mnoho_jmen(int del, int sir) {
      delka = del;
      sirka = sir;
    }
    void mnoho_jmen::zobraz(void) {
      cout << "Z funkce bez parametr∙, plocha = " << delka * sirka << endl;
    }
    void mnoho_jmen::zobraz(int jeden) {
      cout << "Z funkce s jednφm parametrem, plocha = "<<delka * sirka<<endl;
    }
    void mnoho_jmen::zobraz(int jeden, int dva) {
      cout << "Z funkce se dv∞mi parametry, plocha = "<<delka * sirka<<endl;
    }
    void mnoho_jmen::zobraz(float cislo) {
      cout <<"Z funkce s reßln²m parametrem, plocha = "<<delka * sirka<<endl;
    }
    int main(int argc, char **argv)
    {
      mnoho_jmen male, stredni(10), velke(12, 15);
      int cele = 144;
      float pi = 3.1415;
      male.zobraz();
      male.zobraz(100);
      male.zobraz(cele, 100);
      male.zobraz(pi);
      stredni.zobraz();
      velke.zobraz(pi);
      return 0;
    }
    Tento program ukazuje p°ekrytφ metod. Zopakujme si, ╛e funkce je vybrßna na zßklad∞ poΦtu a typ∙ parametr∙. V na╣em p°φpad∞ jsou t°i konstruktory. Pou╛it² konstruktor je urΦen poΦtem parametr∙. V programu vytvo°φme t°i objekty, ka╛d² pomocφ jinΘho konstruktoru. T°φda obsahuje dßle Φty°i metody zobraz. Zjist∞te jak tento program pracuje.
  6. V hlaviΦkovΘm souboru COMPLEX.H je deklarace standardnφ t°φdy complex umo╛≥ujφcφ provßd∞t v²poΦty s komplexnφmi Φφsly. Podφvejte se do tohoto souboru, jak je t°φda deklarovßna. V nßpov∞d∞ zjist∞te, jakΘ operace, konstruktory a sp°ßtelenΘ funkce zde m∙╛eme pou╛φvat.
  7. Vytvo°te program, kter² vypoΦφtß hodnotu v²razu (A + B) / A pro z klßvesnice zadanΘ komplexnφ hodnoty.
  8. Vytvo°te program, kter² bude pracovat jako jednoduchß kalkulaΦka v oblasti komplexnφch Φφsel (sΦφtßnφ, odeΦφtßnφ, nßsobenφ, d∞lenφ, a p°φpadn∞ n∞kterΘ funkce).
  9. Deklarace typu t°φdy m∙╛e zaΦφnat mimo klφΦovΘho slova class i struct nebo union. Typ t°φdy mimo jinΘ ovliv≥uje p°φstupovß prßva ke slo╛kßm. Slo╛ky t°φd typu class jsou implicitn∞ soukromΘ (m∙╛eme to zm∞nit specifikßtory p°φstupu public nebo protected). Slo╛ky t°φd typu struct jsou implicitn∞ ve°ejnΘ (m∙╛eme to zm∞nit specifikßtory p°φstupu private nebo protected). Slo╛ky t°φd typu union jsou implicitn∞ ve°ejnΘ a toto nastavenφ nelze zm∞nit. Vyzkou╣ejte (pokuste se zm∞nit typ n∞kterΘ existujφcφ t°φdy typu class na struct).
  10. Uva╛ujte nßsledujφcφ Φßst programu:

    11. class trida {
      int x;
      int y;
      static int pocet;
    public:
      void nastavx(int novex) {x = novex; };
      void nastavy(int);
      void nastav(int x, int y);
      void nacti(trida bod);
      trida &predej();
    };
    int trida::pocet = 0;
    inline void trida::nastavy(int novey){y = novey;}
    void trida::nastav(int x, int y){
      this->x = x;
      this->y = y;
    }
    void trida::nacti(trida b){
      x = 5 * b.x;
      y = 5 * b.y;
      this->x = 2*x;
      this->y = 2*y;
      this->x = 10 * b.x;
      this->y = 10 * b.y;
    }
    V tΘto ukßzce si pov╣imn∞te n∞kolika v∞cφ. Na identifikßtoru parametru v deklaraci nezßle╛φ (viz metoda nacti) a tento identifikßtor nemusφ b²t uveden (metoda nastavy). Metoda predej nenφ implementovßna a jestli╛e ji nikde nepou╛ijeme pak p°ekladaΦ nesignalizuje chybu. Metody nastavx a nastavy ukazujφ pou╛itφ vlo╛enΘ funkce. V metod∞ nastav jsou pou╛ita stejnß jmΘna parametr∙ jako jmΘna slo╛ek t°φdy. Je zde ukßzßno jak pomocφ ukazatele this m∙╛eme v tomto p°φpad∞ p°istupovat ke slo╛kßm t°φdy. Slo╛ka pocet ukazuje pou╛itφ globßlnφ slo╛ky (v╣echny instance tΘto t°φdy budou mφt tuto slo╛ku spoleΦnou). Takovouto slo╛ku je mo╛no nap°. pou╛φt k poΦφtßnφ existujφcφch instancφ tΘto t°φdy (v ka╛dΘm konstruktoru tΘto t°φdy polo╛ku inkrementujeme a v destruktoru dekrementujeme). Tuto polo╛ku je nutno takΘ definovat (d°φve ne╛ vytvo°φme prvnφ instanci tΘto t°φdy) a inicializovat. Tato t°φda neobsahuje ╛ßdn² konstruktor ani destruktor a jsou tedy vytvo°eny p°ekladaΦem automaticky.
    Zjist∞te, kdy v metod∞ nacti je pou╛ito kterΘ x a y. P°idejte do tΘto t°φdy konstruktor, destruktor a metodu zji╣╗ujφcφ hodnotu slo╛ky pocet a vyzkou╣ejte, ╛e slo╛ku pocet je mo╛no pou╛φt k poΦφtßnφ instancφ tΘto t°φdy.

Zßkladnφ pravidla pro metody:


 
1. Zßklady OOP I