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.