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.
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 Newvybereme 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.
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.
Vytvořte konzolovou aplikaci, která na obrazovku vypíše vaší adresu ve
tvaru:
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).
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.
/* 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.
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.
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
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).
Nyní se pokusíme z tohoto příkladu vytvořit konsolovou aplikaci. Příklad
z nápovědy převedeme na:
#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).
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.
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.
Pokuste se sami vytvořit konzolovou aplikaci, která
pro zadaný poloměr kruhu vypočítá obvod a obsah tohoto kruhu.
Nové pojmy:
Konsolová aplikace je 32-bitový program, který
je spouštěn v okně DOSu pod Windows NT nebo Windows 95.
Aplikace GUI je obvyklý Windowsovský program.
Hlavičkový soubor obsahuje deklarace funkcí
nebo tříd.
Komentář je text určený pro programátora,
při překladu je ignorován.
Deklarace je část kódu, která popisuje funkci
nebo třídu. Deklarujeme také proměnné a konstanty.
Definice je aktuální kód funkce nebo třídy.
Deklarace funkcí a tříd se obvykle umisťují do hlavičkových souborů a definice
do souborů zdrojového kódu.