2. Zßklady programovßnφ v jazyce C++
  1. D°φve, ne╛ budeme pokraΦovat ve vytvß°enφ dal╣φch aplikacφ v C++ Builderu, seznßmφme se se zßklady jazyka C++ (a jazyka C, tj. p°edch∙dce C++). Program v jazyce C je sada definic funkcφ a deklaracφ globßlnφch objekt∙, p°iΦem╛ se jedna funkce musφ jmenovat main. Programovacφ jazyk C pou╛φvß blokovou strukturu. Nap°. t∞lo ka╛dΘ funkce tvo°φ blok.

  2. Jako ukßzku programu uvedeme program vypisujφcφ n∞jak² text:
    int main (void) {
      cout << "Borland C++ Builder" << endl;
      return 0;
    }
    Tento program se sklßdß prßv∞ z jednΘ funkce (musφ se tedy jmenovat main). T∞lo funkce main tvo°φ blok, kter² obsahuje p°φkaz vypisujφcφ text uveden² v uvozovkßch na obrazovku. K v²pisu textu je zapot°ebφ pou╛φt t°φdu C++ nazvanou iostream. Tato t°φda pou╛φvß datovΘ proudy k provßd∞nφ zßkladnφch vstupnφch a v²stupnφch operacφ (vstup dat z klßvesnice a v²stup na obrazovku). Datov² proud cout je pou╛it k zaslßnφ dat do standardnφho v²stupnφho proudu. Datov² proud cin je pou╛φvßn ke vstupu dat z klßvesnice. T°φda iostream implementuje dva specißlnφ operßtory k vlo╛enφ informacφ do proudu a v²b∞ru informacφ z proudu. Vklßdacφ operßtor (<<) je pou╛φvßn pro vklßdßnφ dat do v²stupnφho proudu a operßtor v²b∞ru (>>) je pou╛it k v²b∞ru dat ze vstupnφho datovΘho proudu. K v²stupu informacφ na obrazovku pou╛ijeme:
    cout << "n∞co";
    Tφm program vklßdß text "n∞co" do standardnφho v²stupnφho proudu. Kdy╛ je proveden tento °ßdek programu, pak text je zobrazen na obrazovku.
    T°φda iostream obsahuje specißlnφ manipulßtory, kterΘ mohou b²t pou╛ity k °φzenφ proudu. Zatφm se budeme zab²vat pouze jednφm z nich, a to manipulßtorem endl. Tento manipulßtor vlo╛φ do v²stupnφho proudu od°ßdkovßnφ.
    V²╣e uvedenß ukßzka programu nenφ zcela sprßvnß. D∙vodem je fakt, ╛e vstupy a v²stupy nejsou p°φmo souΦßstφ jazyka C++. D°φve ne╛ pou╛ijeme cout, musφme °φci p°ekladaΦi, kde nalezne popis (nazvan² deklarace) t°φdy iostream.  Deklarace iostream je umφst∞na v souboru nazvanΘm IOSTREAM.H. Tomuto souboru °φkßme hlaviΦkov² soubor. Nß╣ program musφme doplnit o direktivu preprocesoru, kterß zajistφ vlo╛enφ souboru s deklaracφ t°φdy iostream:
    #include <iostream.h>
    int main (void) {
      cout << "Borland C++ Builder" << endl;
      return 0;
    }
    Tento program m∙╛eme p°elo╛it n∞jak²m p°ekladaΦem jazyka C++ a spustit jej v prost°edφ DOSu. V C++ Builderu musφme ale postupovat jinak. Je nutno vytvo°it konzolovou aplikaci (aplikaci, kterß se v prost°edφ Windows chovß jako aplikace DOSu). Spustφme C++ Builder, v nabφdce zvolφme File | New, v zobrazenΘm okn∞ New Items na strßnce New vybereme prvek Console Wizard a stiskneme tlaΦφtko OK. Tφm spustφme pr∙vodce vytvß°enφm konzolovΘ aplikace, kde pouze stiskneme tlaΦφtko Finish. Je otev°en projekt konzolovΘ aplikace. V editaΦnφm okn∞ vidφme tento text (je zde ji╛ takΘ uvedena zatφm prßzdnß definice funkce main):
    #pragma hdrstop
    #include <condefs.h>
    //---------------------------------------------------------------------------
    #pragma argsused
    int main(int argc, char **argv)
    {
            return 0;
    }
    P°i vytvß°enφ konzolov²ch aplikacφ nenφ zobrazeno okno nßvrhovΘho formulß°e (konzolovß aplikace formulß° nepot°ebuje). Pov╣imn∞te si takΘ, ╛e Inspektor objekt∙ je prßzdn². Kdy╛ zapisujeme konzolovou aplikaci, pak m∙╛eme Inspektora objekt∙ uzav°φt a ud∞lat si vφce mφsta pro okno Editoru k≤du. A╛ budeme Inspektor objekt∙ op∞t pot°ebovat, pak v nabφdce zvolφme View | Object Inspector.
    Vygenerovan² program zajistφ v prost°edφ Windows vytvo°enφ konzolovΘ aplikace (je otev°eno okno s Φern²m pozadφm), ve kterΘm je mo╛no provßd∞t programy urΦenΘ pro DOS. Do funkce main m∙╛eme tedy doplnit nß╣ p°φkaz pro vlo╛enφ textu do datovΘho proudu (a dal╣φ dva p°φkazy) a doplnφme direktivy preprocesoru vklßdajφcφ hlaviΦkovΘ soubory (informacφ v zßvorkßch za main si zatφm nev╣φmejte). V editaΦnφm okn∞ tedy bude:
    #pragma hdrstop
    #include <condefs.h>
    #include <iostream.h>
    #include <conio.h>
    //---------------------------------------------------------------------------
    #pragma argsused
    int main(int argc, char **argv)
    {
      cout << "Borland C++ Builder" << endl;
      cout << endl << "Pro pokraΦovßnφ stiskni libovolnou klßvesu...";
      getch();
      return 0;
    }
    Tento program ji╛ m∙╛eme p°elo╛it a spustit a to volbou Run | Run. Je zobrazeno okno konzolovΘ aplikace, vypsßn do n∞j nß╣ text a Φekß se na stisk libovolnΘ klßvesy (to zajistφ funkce getch; jejφ deklarace je umφst∞na v hlaviΦkovΘm souboru CONIO.H). Po stisku klßvesy je okno konzolovΘ aplikace uzav°eno a vrßtφme se op∞t do prost°edφ C++ Builderu. Vyzkou╣ejte.
  3. V p°edchozφ aplikaci vynechßme volßnφ funkce getch. Nynφ po spu╣t∞nφ aplikace je zobrazeno okno konzolovΘ aplikace, vypsßn do n∞j nß╣ text a okno je ihned uzav°eno. Prob∞hne to tak rychle, ╛e si obsah okna nestaΦφme ani prohlΘdnout. Z tohoto d∙vodu je vhodnΘ v╛dy na konci programu konzolovΘ aplikace pou╛φt funkci getch.
  4. Vytvo°te konzolovou aplikaci, kterß na obrazovku vypφ╣e va╣φ adresu ve tvaru:

  5. JmΘno P°φjmenφ
    Ulice ╚φslo
    PS╚ M∞sto
    Program ulo╛te do souboru ADRESA.BPR (jednß se o projektov² soubor; konzolovΘ aplikace se sklßdajφ ze dvou soubor∙ - majφ p°φpony BRP a CPP), p°elo╛te jej a spus╗te. Pov╣imn∞te si, ╛e byl takΘ vytvo°en soubor ADRESA.EXE. Ji╛ p°elo╛enΘ konzolovΘ aplikace je mo╛no spou╣t∞t p°φmo (nejen z prost°edφ C++ Builderu).
  6. Do programu m∙╛eme umis╗ovat takΘ komentß°e. Komentß°e jsou posloupnosti znak∙ pou╛φvanΘ pro komentovßnφ program∙. Jsou urΦeny pouze pro programßtora a p°ekladaΦ je ignoruje. Jsou dva zp∙soby zßpisu komentß°∙. Jedno°ßdkovΘ komentß°e zaΦφnajφ dv∞ma lomφtky. V tomto p°φpad∞ je zbytek °ßdku ignorovßn (tvo°φ komentß°). V na╣em programu byl pou╛it takov²to komentß° (obsahuje pouze znaky pomlΦek a slou╛φ k vizußlnφmu odd∞lenφ jednotliv²ch Φßstφ programu; pokud tento °ßdek vynechßme Φinnost programu se nezm∞nφ). Dal╣φ zp∙sob je zßpis komentß°e mezi znaky /* a */. Tyto komentß°e je mo╛no vlo╛it do textu programu kamkoliv, kde je mo╛no zapsat znak mezery. Mohou obsahovat i n∞kolik °ßdk∙. Pou╛itφ komentß°∙ si ukß╛eme v nßsledujφcφm p°φkladu.

  7. /* Program poΦφtß obvod Φtverce.
       Zadßvßme dΘlku strany Φtverce. */
    //---------------------------------------------------------------------------
    #pragma hdrstop
    #include <condefs.h>
    #include <iostream.h>
    #include <conio.h>
    //---------------------------------------------------------------------------
    #pragma argsused
    int main(int argc, char **argv)
    {
      float strana, obvod;
      cout << "Zadej dΘlku stra\
    ny Φtverce:";
      cin >> strana;
      obvod = 4 * strana;
      cout << endl << "Obvod = " << obvod << endl;
      cout << endl << "Pro pokraΦovßnφ stiskni libovolnou klßvesu...";
      getch();
      return 0;
    }
    Tento program poΦφtß obvod Φtverce. Pov╣imn∞te si pou╛itφ komentß°∙ (jsou zobrazeny mod°e). Datov² proud cin Φte hodnotu z klßvesnice. Proud cout je mo╛no mimo v²pisu textu pou╛φvat i pro v²pis vypoΦφtan²ch hodnot. V programu jsou pou╛ity takΘ dv∞ prom∞nnΘ (strana a obvod; do prvnφ je vlo╛ena hodnota p°eΦtenß z klßvesnice a do druhΘ je vlo╛ena vypoΦφtanß hodnota obvodu Φtverce). Program vyzkou╣ejte.
  8. Pov╣imn∞te si ΦervenΘho °ßdku v p°edchozφm programu. Pokud se bezprost°edn∞ p°ed od°ßdkovßnφm nachßzφ znak obrßcenΘho lomφtka, pak znaky lomφtka a od°ßdkovßnφ jsou vynechßny a jimi odd∞lenΘ °ßdky programu jsou pova╛ovßny za jeden. Toto lze vyu╛φt, pokud pot°ebujeme zapsat hodn∞ dlouh² °ßdek.
  9. Je zapot°ebφ se takΘ seznßmit s pou╛φvßnφm nßpov∞dy. Nap°. pot°ebujeme zjistit co p°esn∞ d∞lß funkce getch. Na jmΘno tΘto funkce v editaΦnφm okn∞ p°esuneme kurzor a stiskneme klßvesu F1. Tφm zobrazφme okno nßpov∞dy pro prvek programu s kurzorem. Pro funkci getch se zde m∙╛eme dozv∞d∞t, ╛e definice funkce je uvedena v hlaviΦkovΘm souboru conio.h, ╛e funkce mß prototyp

  10. int getch(void);
    (s v²znamem prototypu funkce se seznßmφme pozd∞ji), ╛e zφskßvß znak z klßvesnice a nezobrazuje jej na obrazovce. V okn∞ nßpov∞dy se takΘ m∙╛eme podφvat na p°φklad pou╛itφ tΘto funkce. Klikneme na zelenΘm textu "Example" v hornφ Φßsti okna a vidφme p°φklad pou╛itφ tΘto funkce. My se ale dodφvßme na p°φklad pou╛itφ funkce getchar. Nalezneme jej v nßpov∞d∞ a vidφme:
    #include <stdio.h>
    int main(void)
    {
       int c;
    /*
    Note that getchar reads from stdin and is line buffered; this means it will not return until you press ENTER.
     */
       while ((c = getchar()) != '\n')
          printf("%c", c);
       return 0;
    }
    Funkce getchar Φte znak z klßvesnice a zobrazuje jej na obrazovce. P°i Φtenφ je pou╛ita vyrovnßvacφ pam∞╗ (jsou p°eΦteny znaky a╛ do od°ßdkovßnφ a potom jsou po jednom odebφrßny). Funkce je deklarovßna v hlaviΦkovΘm souboru stdio.h. Funkce printf slou╛φ k v²stupu na obrazovku (tato funkce se pou╛φvala v jazyku C).
  11. Nynφ se pokusφme z tohoto p°φkladu vytvo°it konsolovou aplikaci. P°φklad z nßpov∞dy p°evedeme na:

  12. #pragma hdrstop
    #include <condefs.h>
    #include <stdio.h>
    #include <conio.h>
    //---------------------------------------------------------------------------
    #pragma argsused
    int main(int argc, char **argv)
    {
      int c;
      while ((c=getchar())!='\n')
        printf("%c", c);
      getch();
      return 0;
    }
    Program Φte znaky z klßvesnice, dokud nenφ p°eΦten znak od°ßdkovßnφ (v programu je to urΦeno '\n') a p°eΦtenΘ znaky jsou op∞t vypsßny. P°esn∞ji °eΦeno, funkce getchar nejprve Φte znaky a╛ do znaku od°ßdkovßnφ a potom p°i ka╛dΘm volßnφ tΘto funkce vracφ v╛dy jeden z p°eΦten²ch znak∙ (po vyΦerpßnφ znak∙ je p°eΦten dal╣φ °ßdek textu).
  13. Nynφ se struΦn∞ seznßmφme se zßkladnφmi prvky jazyka C++. Jednß se o prom∞nnΘ a datovΘ typy, operßtory, v²razy a p°φkazy °φdφcφ tok programu.

  14. Prom∞nnΘ a datovΘ typy
    Stejn∞ jako jinΘ programovacφ jazyky, i jazyk C umo╛≥uje v programu deklarovat prom∞nnΘ. Prom∞nnΘ obsahujφ hodnoty, kterΘ se b∞hem provßd∞nφ programu mohou m∞nit. V╣echny prom∞nnΘ v C majφ typ a jmΘno. Nap°. v na╣em p°edchozφm programu je deklarovßna jedna prom∞nnß:
    int c;
    Operßtory
    Jazyk C nabφzφ mno╛inu operßtor∙, kterΘ pou╛φvßme k provßd∞nφ r∙zn²ch operacφ. V p°edchozφm programu jsou pou╛ity operßtory = a !=.
    V²razy
    Operßtory, prom∞nnΘ a volßnφ funkcφ m∙╛eme kombinovat do sekvencφ znßm²ch jako v²razy. Vlastnφ prßce programu je provßd∞na pomocφ v²raz∙. V na╣em programu se vyskytuje v²raz:
    (c = getchar()) != '\n'
    P°φkazy °φdφcφ b∞h programu
    V p°edchozφm programu je p°φkaz while. Je to jeden z p°φkaz∙ pro °φzenφ b∞hu programu. Jak vypl²vß z nßzvu, tyto p°φkazy °φdφ pr∙b∞h programu. Jinak °eΦeno, p°φkazy °φdφcφ b∞h programu ovlßdajφ po°adφ, ve kterΘm jsou p°φkazy programu provßd∞ny.
    S t∞mito prvky jazyka C se postupn∞ seznßmφme podrobn∞ji.
  15. Pokuste se sami vytvo°it konzolovou aplikaci, kterß pro zadan² polom∞r kruhu vypoΦφtß obvod a obsah tohoto kruhu.


NovΘ pojmy:
2. Zßklady programovßnφ v jazyce C++