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++