Kurz C++ (2.)

Dostßvß se vßm do rukou druhß lekce kurzu o programovßnφ v C++. V tΘto lekci se koneΦn∞ dostaneme k vlastnφmu programovßnφ, i kdy₧ se bude jednat o pouhΘ zßklady C bez kter²ch se ovÜem neobejdete. SouΦßstφ kurzu je p°φklad, na kterΘm budeme spoleΦn∞ pracovat a kter² si nakonec budete moci ulo₧it na disk a spustit. V°ele ovÜem doporuΦuji si p°φklad napsat vlastnφma rukama a t°eba si ho zkusit modifikovat.

2.1 Zßkladnφ datovΘ typy

DatovΘ typy jsou typy prom∞nn²ch, kterΘ je mo₧no vytvo°it. Prom∞nnß m∙₧e p°edstavovat pam∞¥ovou bu≥ku, ale v∞tÜinou se jednß o blok pam∞ti, kde je ulo₧ena informace jistΘho typu. Prßv∞ typ prom∞nnΘ je nejd∙le₧it∞jÜφ atribut prom∞nnΘ. Jedna prom∞nnß m∙₧e uchovat zßpornΘ Φφslo a druhß zase jen kladnΘ. Musφte p°edem v∞d∞t k Φemu prom∞nnou chcete vyu₧φt, aby program fungoval sprßvn∞. N∞kterΘ chyby odhalφ kompilßtor p°i p°ekladu, ale pozor si musφte dßt p°edevÜφm na ty skrytΘ, kterΘ se projevφ nesprßvnou funkcφ programu. V pr∙b∞hu programu se hodnota prom∞nnΘ m∞nφ, podle druhu operace. M∙₧eme nap°φklad seÜφst dv∞ prom∞nnΘ stejnΘho typu atd. Lze pou₧φt i jistΘ konverze typ∙, ale o tom si podrobn∞ povφme v n∞kterΘ p°φÜtφ lekci.

P°ehled nejpou₧φvan∞jÜφch jednoduch²ch typ∙ jazyka C :

Deklarace	Typ informace	Velikost v bytech
int	celΘ Φφslo	4 (2)
long	celΘ Φφslo	4
short	celΘ Φφslo	2
float	reßlnΘ Φφslo	4
double	reßlnΘ Φφslo	8
long double	reßlnΘ Φφslo	8
char	znak	1
unsigned char	byte	1
BOOL	0 nebo 1 (v C definovßn jako int)	jako int
unsigned short	16-bitovΘ slovo	2
unsigned long	dvojnßsobnΘ slovo	4
unsigned int	neznamΘnkov² int	4
a dalÜφ

N∞kterΘ typy majφ dv∞ varianty a to sice znamΘnkovΘ (signed) a neznamΘnkovΘ (unsigned). Implicitn∞ jsou tyto typy znamΘnkovΘ. Pokud chcete vytvo°it neznamΘnkov² typ, staΦφ p°ed klφΦovΘ slovo typu vlo₧it dalÜφ klφΦovΘ slovo unsigned. Co ale p°esn∞ znamenß znamΘnkov² a neznamΘnkov² typ? Je to snadnΘ. ZnamΘnkovΘ typy mohou nab²vat i zßporn²ch hodnot, ale majφ oproti neznamΘnkov²m typ∙m poloviΦnφ maximßlnφ hodnotu, tak₧e nap°φklad platφ:

Maximßlnφ hodnotu znamΘnkovΘ prom∞nnΘ zjistφme takto: 2^(n-1), kde n je poΦet bit∙, kterΘ prom∞nnß zabφrß v pam∞ti (viz tabulka naho°e - 1 bajt mß 8 bit∙).

2.2 Definice prom∞nnΘ v programu

Za prvΘ si musφme uv∞domit, jak² typ informace chceme äskladovatô. Pak m∙₧eme urΦit datov² typ prom∞nnΘ.
Tak tedy jak definovat prom∞nnou v programu? Definovat znamenß, ₧e p°ekladaΦ p°id∞lφ jmΘno a pam∞¥ pro naÜφ prom∞nnou zatφmco deklarace pouze p°i°adφ jmΘno prom∞nnΘ û p°ekladaΦ nealokuje ₧ßdnou pam∞¥!!!

P°φklad definice prom∞nnΘ :

  int i;
  double d = 1.0;

Takto vytvo°φme celoΦφselnou a reßlnou prom∞nnou. Reßlnß prom∞nnß typu double je ihned inicializovßna na hodnotu 1.0. Prom∞nnß toti₧ po vytvo°enφ nenφ inicializovßna, tak₧e v nφ m∙₧e prakticky cokoliv (v∞tÜinou je to dost obludnΘ zßpornΘ Φφslo) a tφmto se vyvarujem zbyteΦn²ch chyb. P°ekladaΦ nßs upozornφ pokud pou₧φvßme n∞jakou prom∞nnou, ani₧ by jsme jφ p°ed tφm inicializovali.

Definice m∙₧e b²t bu∩ vn∞ nebo uvnit° t∞la funkce. Prom∞nn²m, kterΘ jsou mimo t∞lo jakΘkoliv funkce °φkßme globßlnφ a jsou p°φstupnΘ ze vÜech funkcφ danΘho modulu (souboru .cpp). Globßlnφ prom∞nnß je zruÜena, kdy₧ je ukonΦen cel² program. Pokud je prom∞nnß definovßna uvnit° t∞la funkce, jejφ platnost se omezuje pouze na dobu trvßnφ funkce tzn. ₧e kdy₧ program ukonΦφ funkci zßrove≥ je zruÜena i lokßlnφ prom∞nnß. K lokßlnφ prom∞nnΘ m∙₧eme p°istupovat pouze z funkce, kde je tato prom∞nnß definovßna.

P°φklad definice globßlnφ a lokßlnφ prom∞nnΘ :

  int i; //globalni celociselna promenna viditelna v celem programu
  main()
  {
       double d; //lokalni realna promenna viditelna pouze z funkce main()
  }


2.3. P°i°azenφ

Nynφ mßme definovanΘ jmΘno prom∞nnΘ v programu a m∙₧eme zaΦφt s prom∞nnou pracovat. Kompilßtor nßm p°i°adil bu≥ky v pam∞ti, tak₧e m∙₧eme zφskat adresu naÜφ prom∞nnΘ. Adresu vyu₧ijeme a₧ se budeme zab²vat ukazately (ukazatel = pointer) n∞kdy v p°φÜtφch lekcφch, ale dneska to pro nßs znamenß, ₧e prom∞nnß, prßv∞ proto₧e mß adresu v pam∞ti, je tzv. l-hodnota (l-value). Hodnotu prom∞nnΘ p°i°adφme operßtorem ärovnß seô ( = ). Tak₧e nap°φklad, pokud chceme do prom∞nnΘ i ulo₧it Φφslo 5, napφÜeme :

  int i; // definice promenne
  i = 5; // v i je nynφ hodnota 5


D∙le₧itΘ ovÜem je, aby na levΘ stran∞ p°φkazu byla v₧dy l-hodnota. L-hodnota p°edstavuje adresu, tedy prom∞nnß je l-hodnota, konstatna 5 l-hodnotou nenφ. Nßsleduje trivißlnφ p°φklad:

  int u = 3; // definice a inicializace promenne u
  i = u; // promenna muze byt vlevo i vpravo, i = 3
  i = 2 + u; // i = 5
  i = u * 5 + 10; // i = 25, vyraz muze byt jen na prave strane
  i + 1 = u; // CHYBA!!! Prekladac nastesti tyto chyby odhali pri prekladu...
  1 = u; // JESTE VETSI CHYBA!!!

V C je navφc mo₧nΘ n∞kolikanßsobnΘ p°i°azenφ. Takto m∙₧eme inicializovat n∞kolik prom∞nn²ch najednou.

  u = i = 5; //promenne i a u budou mit hodnotu 5



2.4. Funkce main()

Ve starΘm C musel mφt ka₧d² program funkci main(), kterß se pou₧ila jako vstupnφ bod (entry point) do vaÜeho programu. To znamenß, ₧e kdy₧ se vßÜ program zkompiloval a spustil, jako prvnφ se v₧dy zavolala tato funkce. Z tΘto funkce jste pak volali vaÜe funkce a vßÜ program se provßd∞l dokud funkce main() neskonΦila. Tak₧e touto funkcφ vÜe zaΦalo a taky to p∞kn∞ skonΦilo. Toto platilo a₧ na vyjφmky (pokud jste t°eba pracovali s vφce vlßkny (threads)) na 100%.

V objektovΘm modelu programovßnφ se na tomto a₧ zas tak moc nem∞nφ. A proΦ tedy o tom v∙bec mluvφm? Ve Visual C++ (VC++), ve kterΘm se nynφ uΦφte programovat pracujφ programy zcela jinak! Neplatφ to vÜak jen pro VC++. V²vojovΘ nßstroje jako Visual Basic nebo Delphi pracujφ naprosto stejn∞. Je to dßno tφm, ₧e se jednß o nßstroje pro Windows. Tak₧e p∙vodce t∞chto zm∞n jsou prßv∞ Windows (a jinΘ multitaskingovΘ OS - znamenß to, ₧e m∙₧e pracovat vφce program∙ najednou). Zp∙sob, kter²m pracujφ Windows je na delÜφ povφdßnφ a nßs zatφm nezajφmß, ale nebojte se urΦit∞ se k n∞mu Φasem prokousßme.

Nynφ vßm staΦφ v∞d∞t, ₧e programy, kterΘ budeme vytvß°et budou mφt "zatφm" jen funkci main(), kterou zaΦφnß a konΦφ program. Funkce je ohraniΦena slo₧en²mi zßvorkami {}, jako ka₧dß funkce, kterou kdy v C napφÜete. Funkci main() nikdy nebudete muset volat z vaÜeho k≤du. Tuto funkci volß operaΦnφ systΘm, a¥ u₧ sta°iΦk² DOS nebo padavß Windows.

Funkce main() m∙₧e, ale nemusφ mφt parametry, ale zpravidla vracφ n∞jakou nßvratovou hodnotu, v∞tÜinou typu int. Pokud mß funkce main() parametry, tak je to °et∞zec, kter² napφÜete jako parametr, kdy₧ program spouÜtφte y p°φkazovΘ °ßdky. Mo₧nß se vßm to zdß slo₧itΘ a tak uvedu jednoduch² p°φklad, jak takovß funkce m∙₧e vypadat.
Jak tedy m∙₧e funkce main() vypadat? V r∙zn²ch v²vojov²ch prost°edφch r∙zn∞, nap°φklad takto:

   //prvni priklad
   void main()
   {//zde jsou videt slozene zavorky

     //zadne vstupni parametry
     //zadna navratova hodnota
     //i takovato funkce se muze vyskytnout
     //ale neni to zvykem
   }

   //jiny priklad fce main(), casteji viditelny
   int main()
   {
     //zadne vstupni parametry
     //ale vraci hodnotu, nejcasteji int

     return 0;
   }

   //tak do tretice priklad fce main()
   int main(char args[])
   {
     //tato fce prijima jako parametr retezec z prikazove radky
     //a vraci hodnotu int jako v predchozim priklade
     //jmeno vstupniho parametru se muze lisit od ruznych IDE
     //dokonce jich muze byt i vic!

     return 0;
   }



O funkcφch si samoz°ejm∞ povφme vφce nejspφÜ v p°φÜtφ lekci naÜeho kurzu. Kdy₧ program spouÜtφte z p°φkazovΘho °ßdku (Windows) nebo v DOSu, m∙₧ete zapsat n∞jak² parametr, kter² je pak p°edßn funkci main() jako argument args[], co₧ je pole znak∙ Φili °et∞zec. Tedy nap°φklad:

   C:\WINNT\
   C:\WINNT\cd..
   C:\cd Programs
   C:\Programs\cd Main
   C:\Programs\Main\main.exe test



Zde p°edßvßte funkci main() °et∞zec "test", to znamenß, ₧e po spuÜt∞nφ programu v prom∞nnΘ args[] bude opravdu °et∞zec "test" a vy s nφm m∙₧ete cokoliv d∞lat, t°eba vypsat na obrazovku. Takto m∙₧e u₧ivatel vaÜeho programu m∞nit chovßnφ programu, ani₧ by znal, jak vypadß vlastnφ k≤d.

My si ukß₧eme konkretnφ p°φklad, jak parametry fungujφ ve Visual C++, pokud vytvo°φte konzolovou aplikaci (postup je vysv∞tlen² v kurzu o IDE VC++). Kdy₧ se podφvßte na funkci main(), urΦit∞ vßm p°ijde slo₧itß, proto₧e v∙bec nevypadß tak, jak jsem p°ed chvilkou °φkal. Mßte pravdu ve VC++ vypadß funkce main() jinak ne₧ jinde. Na prvnφ pohled vidφte, ₧e mß dva parametry, mφsto jednoho. Prvnφ parametr argc urΦuje poΦet vßmi zadan²ch parametr∙ v p°φkazovΘ °ßdce. Jeho minimßlnφ hodnota je 1, proto₧e se jako parametr bere i nßzev programu, tedy nap°φklad "main.exe" a i tento °et∞zec "vnikß" do funkce main(). Druh² parametr argv[] je troÜiΦku slo₧it∞jÜφ, ale o to vychytan∞jÜφ. Je to ukazatel (₧e nevφte co to je? tφm se zatφm netrapte) Φili adresa n∞jakΘ bu≥ky v pam∞ti. Ukazatel na pole znak∙. Znφ to nesmφrn∞ slo₧it∞, ale ve skuteΦnosti je to velmi jednoduchΘ. Zkrßtka parametr argv[] uchovßvß vÜechny °et∞zce, kterΘ jste zapsali do p°φkazovΘ °ßdky. K jednotliv²m °et∞zc∙m p°istupujeme pomocφ index∙ v intervalu 0 a₧ (argc-1). Nßsledujφcφ p°φklad vypφÜe vÜechny parametry v p°φkazovΘ °ßdce nezßvisle na jejich poΦtu.

   #include "stdafx.h"

   //vlozeni standardniho hlavickoveho souboru (kvuli fci cout)
   #include <iostream.h>

   int main(int argc, char* argv[])
   {
     //smycka typu for bezi od 0 do argc-1
     for(int i = 0; i < argc; i++) {
         //funce cout vypisuje jednotlive parametry
         //na obrazovku
         //vsimnete si formatovanφ jednotlivych radku
         //funkci cout a cin si popiseme pozdeji
         cout << "Argument #" << i << " :" << argv[i] << "\n";
     }

    return 0;
   }


2.5. HlaviΦkovΘ soubory a funkce cout a cin

"Funkce" cout a cin jsou deklarovßny v hlaviΦkovΘm souboru iostream.h, kter² musφte vlo₧it do svΘho programu, abyste je mohli pou₧φt. Vklßdßnφ hlaviΦkov²ch soubor∙ je vid∞t na p°edchozφm p°φkladu. Pokud se jednß o standardnφ hlaviΦkov² soubor, tzn. o soubor vytvo°en² t²mem fy Microsoft, uzavφrß se jmΘno souboru do lomen²ch zßvorek: <>. Pokud jde o vßÜ hlaviΦkov² soubor, kter² jste napsali vy, uzavφrß se jmΘno souboru do ·vozovek: "". IDE tak poznß odkud mß vklßdat hlaviΦkovΘ soubory. Standardnφ hlaviΦkovΘ soubory jsou ulo₧eny v adresß°i vlastnφho IDE (nap°. C:\Program Files\Microsoft Visual Studio\VC98\Include) a vaÜe soubory jsou ulo₧eny v adresß°i vaÜeho programu (nap°. C:\Programs\Main\).

Mo₧nß se divφte, ₧e za funkcemi cout a cin nepφÜi zßvorky jako u funkce main(). Je to proto, proto₧e cout a cin vlastn∞ nejsou funkce:-) Jednß se o objekty jazyka C++, kterΘ pou₧φvajφ tzv. proudy (streams). Proudy mohou b²t r∙znΘ, nap°φklad vstup a v²stup na tiskßrnu, do souboru a na obrazovku (cout a cin). V C pod DOSem se pou₧φvali funkce printf() a scanf(), ale my budeme po₧φvat objekty cin a cout, proto₧e se uΦφme C++. Pro p°φstup k proud∙m se pou₧φvajφ specißlnφ operßtory: << a >>, jak jste si jist∞ vÜimli v p°edchozφm p°φpad∞.

Objekt cout, kter² jsme p°ed chvilkou pou₧ili, se pou₧φvß pro v²stup na monitor. Pou₧itφ si ukß₧eme na jednoduchΘm p°φkladu:

   int i = 5;//definice promene i = 5

   cout << "Ahoj\n";// vypise na monitor "Ahoj" a odradkuje
   cout << i << "\n";// vypise na monitor obsah promene i a odradkuje
   cout << "Obsah i: " << i << "\n";//vypise na monitor "Obsah i:", obsah i a odradkuje


Je vid∞t, ₧e cout m∙₧eme pou₧φt k zobrazenφ °et∞zce i obsahu prom∞nΘ. Asi se divφte, copak d∞lajφ znaky "\n". Tento "dvojznak" je ve skuteΦnosti jeden znak, kter² zajistφ od°ßdkovßnφ. Odborn∞ se naz²vß escape sekvence, kter²ch je celß °ada:

Sekvence	Hodnota	V²znam
\n	0x0A	novß °ßdka (newline, linefeed - LF)
\r	0x0D	nßvrat na zaΦßtek °ßdky (carrige return - CR)
\f	0x0C	novß strßnka (formfeed - FF)
\t	0x09	tabulßtor (tab - HT)
\b	0x08	posun doleva (backspace - BS)
\a	0x07	pφsknutφ (alert - BELL)
\\	0x5C	zp∞tnΘ lomφtko (backslash)
\'	0x2C	apostrof (single quote)
\0	0x00	nulov² znak (null character - NUL)

Objekt cin (nynφ vφte, ₧e se jednß o objekt) se pou₧φvß velmi podobn∞. Nßsleduje op∞t jednoduch² p°φklad:

   int i; //definice promene i

   cin >> i;//nacteni ciselne hodnoty do promene i
   cout << "Obsah i: " << i << "\n";//vypsani obsahu i (viz vyse)



VÜim∞te si, ₧e "Üipky" u cin jsou na opaΦnou stranu ne₧ u cout. To proto, ₧e se jednß o opaΦn² sm∞r proudu - z klßvesnice do prom∞nnΘ je >>, zatφmco z prom∞nnΘ na monitor jsou "Üipky" opaΦn∞ <<. A to je celΘ kouzlo vstupu a v²stupu na obrazovku. Pokud jste to pochopili, pak mßte vyhrßno a pokud ne, tak si s tφm nelßmejte hlavu, proto₧e Φasem se vÜechno vyjasnφ :-)

2.6. Operßtory

Pomocφ operßtor∙ provßdφme aritmetickΘ, ale i logickΘ operace s prom∞nn²mi. Nynφ u₧ vφte, jak prom∞nnou vytvo°it (definovat), tak₧e u₧ nezb²vß nic jinΘho, ne₧ se nauΦit s prom∞nn²mi pracovat. Uvedu krßtk² p°ehled, kde by m∞ly b²t uvedeny vÜechny zßkladnφ operßtory. VÜechny tyto operßtory jsou binßrnφ tzn, ₧e pot°ebujφ dva operandy a vracφ v²sledek.

Binßrnφ operßtory
V²znam operace	Syntaxe	P°φklad
SΦφtßnφ	+	50 + 50 = 100
OdeΦφtßnφ	-	100 - 50 = 50
Nßsobenφ	*	10 * 10 = 100
D∞lenφ	/	100 / 10 = 10
D∞lenφ modulo	%	7 % 3 = 1 (zbytek po d∞lenφ)
Bitov² posun doleva	<<	10 >> 1 = 5
Bitov² posun doprava	>>	10 << 1 = 20
Logick² souΦin	&	1 & 2 = 0 nebo 3 & 6 = 2
Logick² souΦet	|	1 | 2 = 3 nebo 3 | 6 = 7

Dßle rozliÜujeme unßrnφ operßtor², kter²m staΦφ jeden operand.

Unßrnφ operßtory
V²znam operace	Syntaxe	P°φklad
Unßrnφ plus - kladnΘ Φφslo	+	+12547
Unßrnφ minus - zßpornΘ Φφslo	-	-12547

Specißlnφ unßrnφ operßtory

• inkrement ++
• dekrement --

++prom∞nnß
• prom∞nnß je inkrementovßna (zv∞tÜenß o jedniΦku) p°ed pou₧itφm
  
• nejd°φve je prom∞nnß zv∞tÜena o jedniΦku a potΘ je vrßcena tato novß hodnota

prom∞nnß--
• prom∞nnß je dekrementovßna (zmenÜenß o jedniΦku) p°ed pou₧itφm
  
• je vrßcena p∙vodnφ hodnota prom∞nnΘ a potΘ je prom∞nnß zmenÜena o jedniΦku

2.7. Co bude v p°φÜtφ lekci?

P°φÜt∞ si povφme n∞co o °φdφcφch strukturßch (if a if-else) a iteraΦnφch cyklech (for, while a do-while), abyste dovedli °φdit b∞h programu. Dßle si povφme n∞co o p°φkazech switch, break a continue. Pokud budete mφt n∞jakΘ dotazy, napiÜte mi na emailovou adresu jiri.formanek@seznam.cz.

T∞Üφm se p°φÜt∞ nashledanou.