Učebnice Programování V C/C++ PROGRAMOVÁNÍ V C/C++ - 1. DÍL................................................................................................................. 3 PŘEDPOKLADY .............................................................................................................................................. 3 CO JE TO PROGRAMOVÁNÍ ............................................................................................................................... 3 "KDE SEŽENU TEN PROGRAM?" ........................................................................................................................ 3 INSTALACE A BLIŽŠÍ SEZNÁMENÍ ........................................................................................................................ 3 CO " TEN PROGRAM" DĚLÁ ............................................................................................................................... 3 NA ZÁVĚR PRVNÍHO DÍLU ................................................................................................................................. 3 PROGRAMOVÁNÍ V C/C++ - 2. DÍL................................................................................................................. 4 NÁŠ PRVNÍ PROGRAM ..................................................................................................................................... 4 KOMENTÁŘE ................................................................................................................................................. 4 ŘÁDKY CO ZAČÍNAJÍ # ..................................................................................................................................... 4 VLASTNÍ PROGRAM ........................................................................................................................................ 4 J EŠTĚ TROCHU HYGIENY ................................................................................................................................. 5 CO SI ZAPAMATOVAT ...................................................................................................................................... 5 PROGRAMOVÁNÍ V C/C++ 3. DÍL................................................................................................................... 6 PROMĚNNÉ................................................................................................................................................... 6 ZÁKLADNÍ TYPY PROMĚNNÝCH ......................................................................................................................... 6 JAK SI " UDĚLÁME" TAKOVOU PROMĚNNOU .......................................................................................................... 7 KDE DEKLAROVAT PROMĚNNOU?...................................................................................................................... 7 CO MŮŽEME S ČÍSELNOU PROMĚNNOU DĚLAT? ................................................................................................... 7 D NEŠNÍ JEDNODUCHÝ PROGRAM ...................................................................................................................... 8 PLATNOST PROMĚNNÝCH ................................................................................................................................ 8 DO PŘÍŠTĚ.................................................................................................................................................... 8 PROGRAMOVÁNÍ V C/C++ 4. DÍL................................................................................................................... 9 BLOK KÓDU .................................................................................................................................................. 9 VĚTVENÍ PROGRAMU ...................................................................................................................................... 9 CO KDYŽ POTŘEBUJI VÍCE PODMÍNEK: .............................................................................................................. 11 DALŠÍ KOUZELNÉ SLOVO: ELSE ....................................................................................................................... 11 ZKUŠEBNÍ PROGRAM .................................................................................................................................... 11 DODATEK O PLATNOSTI PROMĚNNÝCH............................................................................................................. 12 PROGRAMOVÁNÍ V C/C++ 1. BONUS .......................................................................................................... 13 PRAVIDLA ................................................................................................................................................... 13 JAK NA TO?................................................................................................................................................. 13 PLÁN ......................................................................................................................................................... 13 PŘÍPRAVA NA SMYČKU .................................................................................................................................. 13 SMYČKA ..................................................................................................................................................... 13 KÓD .......................................................................................................................................................... 13 PROGRAMOVÁNÍ V C/C++ 5. DÍL................................................................................................................. 15 WHILE ...................................................................................................................................................... 15 VARIACE NA WHILE....................................................................................................................................... 15 SMYČKA FOR .............................................................................................................................................. 15 U ČÍME SE ČÍST ............................................................................................................................................ 16 SHRNUTÍ .................................................................................................................................................... 16 PROGRAMOVÁNÍ V C/C++ 6. DÍL................................................................................................................. 17 VYHODNOCOVÁNÍ VÝRAZŮ ............................................................................................................................. 17 L ÍNÉ VYHODNOCOVÁNÍ.................................................................................................................................. 17 FUNKCE ..................................................................................................................................................... 18 V PRAXI...................................................................................................................................................... 18 PROGRAMOVÁNÍ V C/C++ 7. DÍL................................................................................................................. 21 D NEŠNÍ TÉMA .............................................................................................................................................. 21 PREPROCESOR A JEHO DIREKTIVY .................................................................................................................. 21 # INCLUDE< SOUBOR.H> ................................................................................................................................. 21 # INCLUDE"SOUBOR.H" .................................................................................................................................. 21
# DEFINE JMENO HODNOTA ....................................................................................................................... 21 DALŠÍ DIREKTIVY ......................................................................................................................................... 22 N ĚKTERÉ DALŠÍ OPERÁTORY ......................................................................................................................... 22 O PERÁTORY -- A ++ ..................................................................................................................................... 22 PROGRAM .................................................................................................................................................. 23 PŘÍŠTĚ ...................................................................................................................................................... 23 PROGRAMOVÁNÍ V C/C++ 8. DÍL................................................................................................................. 24 POINTERY .................................................................................................................................................. 24 JAK VYPADÁ PAMĚŤ ...................................................................................................................................... 24 PROMĚNNÉ A PAMĚŤ .................................................................................................................................... 24 STACK A HEAP............................................................................................................................................. 24 POINTERY .................................................................................................................................................. 24 JAK SE DEKLARUJE POINTER .......................................................................................................................... 25 KAM MOHOU POINTERY UKAZOVAT .................................................................................................................. 25 SHRNUTÍ .................................................................................................................................................... 25 PROGRAMOVÁNÍ V C/C++ 9. DÍL................................................................................................................. 26 CO JE TO ALOKACE ...................................................................................................................................... 26 JAK SE ALOKUJE .......................................................................................................................................... 26 D EALOKACE................................................................................................................................................ 26 PRÁCE S POINTERY ...................................................................................................................................... 26 NULL A CO JE TAM, KDYŽ TAM NIC NENÍ?? ....................................................................................................... 27 KDYŽ POINTER UKAZUJE NA STACK ................................................................................................................. 27 SHRNUTÍ .................................................................................................................................................... 27 SLUŠNÉ CHOVÁNÍ ........................................................................................................................................ 27 CVIČENÍ ..................................................................................................................................................... 28
Programování v C/C++ - 1. díl Konečně tu máme i něco pro opravdové programátory. Novou rubriku programování otevírá série článků o jazyce C (a později C++). Nepředpokládá žádné dřívější zkušenosti s programováním, přesto je případná znalost php díky velké syntaktické podobnosti výhodou (přestože historicky je původcem této syntaxe právě jazyk C). Vítejte na začátku prvního dílu. Pokud čtete tento článek, chcete se nejspíš naučit programovat. My se v tomto seriálu budeme učit programovat v jazyce C, což je docela vhodný začátek i pokud se rozhodnete s programováním pokračovat později, třeba už profesionálně. Rád bych upozornil, že řada informací je nekompletních, jde mi hlavně o to, aby se začátečníci orientovali.
Předpoklady Předpokladem pro tento seriál je základní znalost počítačů (co je to soubor, spustitelný soubor atp.) a matematiky (výraz, neznámá).
Co je to programování Pokud si nejste jisti tím, co je to programování (vzpomínám si na jednoho známého jak říká "ja stejně vůbec nechápu jako jak se to dělá, že ten počítač hraje hokej"), není se za co stydět. Program je vlastně takový seznam činností (program ;)), které má počítač provést. Taková kuchařka. Vezmi hrnec, dej do něj mléko, začni vařit, přidej puding, dokud není husté tak míchej, přestaň vařit, rozlévej do mističek. Jednoduché!
"Kde seženu ten program?" Tradiční otázka začátečníků je "kde seženu ten program co se to v něm dělá". Ten program co se to v něm dělá je vlastně něco jako textový editor, kam píšete svůj program. Co se týče freewarových programů, doporučuji DevC++ ( stáhnout). Pokud se Vám nějakým způsobem dostalo do ruky Visual C++ nebo Borland C/C++ pro DOS, mohu také doporučit. Já se budu soustředit na Dev-C++, protože je dostupné Vám všem zdarma a bude pro většinu také první volbou.
Instalace a bližší seznámení Instalace by měla být bezproblémová. Vybrat adresář zvládnete určitě sami, volby můžete nechat zaškrtnuté všechny. Po instalaci si založíme nový projekt. V hlavním menu zvolíme Nový->Projekt, za typ zvolíme konzolovou aplikaci/console application, pojmenujeme si ho a uložíme. Některé verze vygenerují už připravený základní zdrojový kód, některé ne (potom bude dobré přidat do projektu nějaký soubor přes Projekt->Nový soubor). Soubory v projektu se zpravidla ukládají s koncovkou .c nebo .cpp. Pro ty z vás, kteří se ještě nezorientovali, do budoucna se můžeme dostat do situace, že pro projekt budeme mít i více zdrojových kódů (souborů), proto tedy existují projekty - aby nám umožnili pohodlně spravovat zdrojové soubory.
Co "ten program" dělá Ten program je vlastně takový balíček více různých programů. První z nich Vám slouží jako editor a nazývá se vývojové prostředí. Dalším důležitým programem je tzv. compiler, což je program který přeloží program z naší lidské formy do toho, čemu rozumí počítač. Aby toho nebylo málo, je často potřeba více těchto překladů compileru dát dohromady, aby nám z jednotlivých kapitol vznikla celá kniha (např. tedy výsledný spustitelný soubor) - o to se stará linker. Nemusíte se ale všech těchto pojmů bát. Vše lze velmi jednoduše ovládat z vývojového prostředí stiskem několika kláves.
Na závěr prvního dílu Prokousali jsme se tím nezáživným a příště už můžeme začít s vlastním programováním. Napíšeme si jednoduchý program, který nás dovede pozdravit a vysvětlíme si pár základních principů.
Programování v C/C++ - 2. díl A je tu další díl seriálu o programovaní v jazyku C. Minule jsme měli takovou malou seznamovací party, teď už nás ale čeká první rande, vlastně první program.
Náš první program S chutí do toho, hned je hotovo. Založte si nový projekt (typu konzolová aplikace), nějak si ho pojmenujte, pokud vám Dev-C++ už něco vygenerovalo, smažte to. Pokud ne, zkopírujte si následující část kódu. /* tohle je náš první program */ #include<stdio.h> //tady je to důležité int main() { //pozdravíme printf("Ahoj!"); //počkáme na klávesu getchar(); //této řádky si nevšímejte return 0; } Je to takový kraťoučký prográmek, který nás pozdraví, počká až "to odklepneme" a skončí.
Komentáře První řádek začíná dvojicí znaků /*. Tak začíná tzv. komentář, tedy nějaká poznámka, kterou si programátor ke svému programu napsal (tady "tohle je náš první program"). Komentář ale musí i nějak končit. Od toho máme dvojici znaků */. Vše co je mezi /*a*/ je pro kompilátor (compiler) neviditelné, nevšímá si toho. Komentář může mít i více řádek, pokud vám ale stačí řádek jen jeden, můžete psát komentář i za dvé lomítka // (kompilátor si nebude všímat toho co je mezi těmito lomítky a koncem řádku. Není potřeba ho tedy nijak ukončovat, jeho konec je vždy tam, kde končí řádek), jako jsem to udělal o několik řádek níže.
Řádky co začínají # Řádky co začínají # si nebudeme zatím vůbec všímat. Někdy později jim budeme věnovat celou kapitolu.
Vlastní program Vlastní program, tedy náš seznam úkolů pro počítač, je mezi znaménky { a } (složené závorky). To co zbylo před našimi závorkami - main() - si také vysvětlíme v některém pozdějším díle (pro dnešek se budete muset smířit s tím, že pracujme jen a jen s částí mezi složenými závorkami a sem tam nějakým tím komentářem). Nad každým důležitým řádkem jsem napsal, co znamená. Pamatujte si, že jednotlivé instrukce a příkazy pro počítač se od sebe oddělují vždy středníkem. Můžete jich mít na jedné řádce klidně deset (no brrr), ale je důležité je mít oddělené středníkem (jazyk C rozlišuje mezi malými a velkými písmeny, to znamená že printf a PrintF NENÍ to samé!!). Podle toho kompilátor pozná, kde končí jeden příkaz a začíná druhý. Pokud je potřeba k příkazu připojit ještě nějaký parametr, přesněji specifikovat, co se bude dít, je potřeba to uvést v závorkách (příkazy - také se jim říká funkce - po pravdě parametry buď mají, a mají jich přesný počet s přesným významem, nebo nemají (výjímky jsou, ale zabývat se jimi nebudeme). Máme-li tedy, jako ve výše uvedeném příkladu printf("ahoj!"); Znamená to, že máme funkci (příkaz, instrukci), která se jmenuje printf (což znamená "print formated", česky "vytiskni formátované"… funkce mívají často nějaká intuitivní jména) a která vytiskne na obrazovku to, co dostane jako parametr (nějaký text mezi dvojicí uvozovek), v tomto případe bude tedy na obrazovce: Ahoj! Hned jak se náš text vytiskne, provede se funkce getchar (která nemá žádný parametr, takže závorky jsou sice prázdné, ale musejí tam být!), která "přečte" z klávesnice první stisknuté tlačítko (česky "zjisti znak"), tím pádem ale i musí počkat než se zmáčkne :). To je tedy náš první program. Přeložíme ho Ctrl-F10, spustíme Ctrl-F9 (doufám že jste od minule ještě Dev-C++ nesmazali…), chvíli počkáme, než se program přeloží, a mělo by se vám všem objevit okno a v něm Ahoj. Stiskněte klávesu, a program se ukončí. POZN: je potřeba soubor uložit s koncovkou .C, pokud už jste ho ale uložili s koncovkou .CPP a nechce se Vám ho ukládat znovu, stačí přidat před main slovo "int" a před } přidat řádek "return 0;" (vše samozřejmě bez závorek a uvozovek)
Ještě trochu hygieny I Váš kód potřebuje hygienu. Když ho nebudete pořádně udržovat, bude za chvíli zarostlý a ošklivý. To, o čem tu budu mluvit, je důležité. Ač se Vám to teď nezdá, je velmi dobré mít kód přehledný. Snažte se dodržovat nějaký svůj styl. Pokud možno by jeho součástí mělo být, že píšete vždy jeden příkaz na jednu řádku. Pokud to má logicky nějaký smysl, můžete třeba občas vložit prázdnou řádku (jako když píšete nějaký sloh nebo zápis ze schůze - mělo by to být přehledné. Na rozdíl od třeba knihy se ale musíte v tomto textu dobře orientovat na první pohled. Nemůžete ho pokaždé číst od začátku. Dobré a přehledné členění je proto důležité). Dobrým zvykem je také psát za čárku mezeru a někteří ji dávají i za levou závorku a před pravou závorku, to aby věci v závorce byly trochu odsazené (časem zjistíte, že věci v závorkách se daleko častěji mění než např. jména funkcí ;)). Také se nebojte odsazovat (třeba jako v našem příkladu, vše mezi { a } je odsazené (o jeden TAB nebo několik mezer, jak Vám to vyhovuje)). Časem to správné rozmístění dostanete do oka. Podobná věc platí pro komentáře. Nešetřete jimi, pokud budete mít třeba poměr komentář: kód 1:1 (a není naprosto zřejmé, co chcete dělat a proč to chcete dělat), je to výborné. Po několika dnech nebo stovkách řádků třeba zapomenete, co tenhle řádek dělá a hlavně proč to vlastně dělá… hmmmm
Co si zapamatovat Pamatujte si, že jednotlivé funkce/příkazy se od sebe oddělují středníkem (v podstatě jsou to výrazy. Každou funkci nebo příkaz si můžete představit jako funkci v matematickém výrazu. Pokud věcem co jsem do této závorky napsal moc nerozumíte, nic se neděje). Pamatujte si že se komentář píše mezi /* a */ nebo za // a že platí, že čím více, tím lépe. Komentář slouží k tomu, aby jste se ve vlastním kódu lépe vyznali! Pokud má funkce nějaké parametry, píšou se do závorky za jméno funkce/příkazu a oddělují se čárkou. Pokud ne, píšou se tam prázdné závorky. Ne že by vám to bez nich neprošlo, ale znamenalo by to něco jiného :o a to my nechceme.
Programování v C/C++ 3. díl Dnes si budeme povídat o proměnných a o jejich druzích. Konečně už budete schopni napsat program, který bude opravdu něco dělat a v příštím díle si už naprogramujeme malinkatou hru, to jen aby jste měli motivaci do začátku ;-)
Proměnné Proměnnou si můžete představit jako nějakou hodnotu. Tu hodnotu můžete různě měnit, což je velmi důležité, a také z ní můžete číst, což je neméně důležité. Kolem a kolem, v proměnných si uchováváte hodnoty, které si potřebujete ve vašem programu pamatovat. Vlastně naprostou většinu hodnot si je potřeba pamatovat. Pokud by jste psali například úplně jednoduchý program, který se zeptá uživatele na jeho jméno a potom ho pozdraví, je potřeba se uživatele na to jméno zeptat a potom ho tím jménem pozdravit. Pokud bychom si ovšem jméno uživatele nezapamatovali (mi jsme se ho zeptali, ale nezapamatovali jsme si ho!), nebudeme si na něj (na to jméno) moci vzpomenout, až jím budeme chtít pozdravit uživatele. Prostě jsme se zeptali, jedním uchem šlo dovnitř, druhým ven a když má teď váš program pozdravit, připadá si jako po požití návykových látek ;). Proto je potřeba si věci/hodnoty v programu pamatovat (říká se ukládat do proměnných). Pokud by jste si hodnoty nemuseli pamatovat, nemají vlastně pro Vás žádný účel a potom jste je (např. od uživatele) nemuseli ani získat.
Základní typy proměnných Proměnná tedy v sobě uchovává nějakou hodnotu. Takovou hodnotou může být například číslo nebo také text. Prostě, druhy proměnných jsou různé a také se liší v tom, jakým způsobem si je počítač pamatuje (tím se ovšem ještě zabývat nebudeme). V tabulce je uvedeno několik druhů číselných proměnných (proměnnými, které si pamatují text, se budeme zabývat někdy jindy).
Název
rozsah bez znaménka (unsigned)
rozsah se znaménkem (signed nebo samotné)
char
0 až 255
-128 až 127
short short int
0 až 65,535
–32,768 až 32,767
0 až 4,294,967,295
–2,147,483,648 až 2,147,483,647
int long long int
Poznámky
rozsah pro typ int se liší podle platformy (data v tabulce platná pro 32-bitové operační systémy, např. Windows 95/98/NT/XP, Linux atp.)
float
6 číslic pro desetinnou a celočíselnou část dohromady
vždy se znaménkem, ne vždy přesné
double
14 číslic pro desetinnou a celočíselnou část dohromady
vždy se znaménkem, ne vždy přesné
Jak vidíte, liší se tím, jak velká čísla si mohou pamatovat (pokud by jste se do proměnné snažili uložit větší číslo, než je schopna si pamatovat, dojde k tzv. přetečení (anglicky overflow), kdy se proměnná nastaví na hodnotu, která je rovna tomu, o kolik se tam proměnná nevešla (varování: vždy by jste měli vědět jakých hodnot bude proměnný nabývat už když program píšete!). Pokud by jste potřebovali pracovat s ještě větším rozsahem čísel, než jaká jsou tu uvedena, museli by jste použít nějakou pomocnou knihovnu (nic, čím by jste se zrovna teď měli zabývat). Většina jmen proměnných má svůj význam (jak jsme si řekli minule, je důležité rozlišovat mezi malými a velkými písmeny!). Název char je od anglického character - znak (proč? řekněme že z "historických důvodů"), int je od anglického integer - celé číslo, long je long - "dlouhé" číslo, float je float - vznášet se, plout - zde kvůli plovoucí desetiné čárce a konečně double - jako dvojitá přesnost pro desetiná čísla. Potom je tu přívlastek (dává se před typ proměnné) signed a unsigned, což znamená ze se znaménkem a bez znaménka. Je-li číslo se znaménkem, pamatuje si počítač jen poloviční rozsah (místo 256 různých čísel při rozsahu 0-255 je to 256 různých čísel se znaménkem při rozsahu -128 až 127. Slova signed a unsigned jdou "napasovat" před všechny celočíselné typy, desetinné typy jsou vždy se znaménkem. Můžete používat i názvy samotné, pak si k tomu počítač (záleží na nastavení kompilátoru, ale zpravidla) přimyslí signed a z char se stane signed char atp. Příklad použití signed a unsigned unsigned short unsigned short int signed long int unsigned char Stručně zopakováno, máme několik typů celočíselných a desetinných. Liší se v tom, jaký rozsah čísel si pamatují, a u celočíselných v tom, jestli jsou se znaménkem nebo ne.
Jak si "uděláme" takovou proměnnou Pokud potřebujete uložit nějakou tu hodnotu, potřebujete proměnnou. My už jsme si řekli, jaké jsou jejich typy a co si umí "pamatovat". Těď si ukážeme, jak si takovou proměnnou "uděláme" nebo vytvoříme. Řekněme, že chceme uložit číslo v rozsahu 0-10, např. 8. Zvolíme tedy typ char (nebo unsigned char), protože do jeho rozsahu se pohodlně vejdeme (větší rozsahy zabírají více paměti, proto je lepší používat čísla s nejmenším dostačujícím rozsahem). A jak to teď uložíme? Je potřeba zvolit si jméno/název, pod kterým si budeme tu hodnotu ukládat, např. nase_cislo (jména proměnných nesmí začínat číslicí, mohou obsahovat malá a velká písmena, číslice a podtržítko; správná jména jsou např. mojecislo MojeCislo MojeCislo2 Moje_cislo _cislo_ Naopak špatně jsou např. 1_mojecislo moje-cislo moje&cislo moje cislo Dvě proměnné (vůbec dvě jména, tj. jména funkcí, proměnných atp. nemohou mít stejný název. Proto se vám může někdy stát, že vaše jméno už je použito… potom použijte jiné). Do kódu to pak zapíšeme jako //tohle je moje prvni promenna char moje_cislo; Jak jste si už možná všimli, nejprve napíšete typ proměnné, potom její jméno a středník. Další příklady toho, jak vypadá deklarace proměnné jsou signed char my_signed_number; int my_integer_number; double HypergalacticSpeed; float fVelocity; pokud potřebujete více proměnných stejného druhu a nechce se Vám psát typ proměnné znovu a znovu, můžete jednotlivé proměnné (jejich jména) stejného druhu oddělit čárkou a za poslední udělat středník. char prvniCislo, DruheCislo, treti_cislo, CTVRTECISLO; Tomuto (ať už chcete jen jednu nebo více proměnných) se říká deklarace proměnných, tj. Vy deklarujete, že budete používat proměnnou určitého jména a typu a kompilátor se díky tomu může na Váš program "lépe připravit". Než budete proměnnou používat, musíte ji deklarovat.
Kde deklarovat proměnnou? POZNÁMKA: minule byla velká diskuse o tom, jestli se učíme C nebo C++ a co je lepší. Já jsem seriál pojmenoval Programováni v C, protože jsem chtěl dát jasn ě najevo, že se tu nebudeme zabývat objektově orientovaným programováním, ale že se budeme učit základy programování. Pro úplnost tedy - budu se snažit odlišit alternativy jak pro C tak pro C++. Pro Vás, co začínáte, nelamte si hlavu, vyberte si C++, proto že je pohodlnější na práci a bude se vám žít blaze. Žádné změny není třeba podnikat, soubory ukládejte s koncovkou .cpp a máte vystaráno. My si budeme říkat, jak je to pro C++ (pro ty z vás, kteří to chtějí a musejí vědět nebo musí z nějakého důvodu progra movat v C se musí deklarovat proměnné na začátku funkce, hned za levou složenou závorkou) . Proměnnou můžete deklarovat kdekoliv mezi { a } v příkladu z minulého dílu nebo kamkoliv rozumně v programu (zkoušejte to, když to bude špatně, počítač vám to nedovolí) Budu to dělat pořád a pořád: snažte se udržovat si pořádek v kódu, dobře odsazovat (TABem nebo mezerníkem, např. Visual C++ už to dělá automaticky), dnes ještě zdůrazním, aby jste si dobře pojmenovávali proměnné, to znamená žádné bbb, abc, fgh atp, ale hezky celým jménem nebo nějakou zkratkou. Pro inspiraci některé styly, kterými programátoři zapisují proměnné: int iMojePromenna; int moje_promenna; int mojePromenna; int MojePromenna;
Co můžeme s číselnou proměnnou dělat? Je to číslo, můžeme s ním tedy dělat jednoduché operace jako sčítání, odčítání, násobení a dělení. Pokud něco podobného chcete dělat, zapisujete to jako normální rovnici v matematice (středník na konci). Například: a = b + c;
Jako v matematice, a se bude rovnat (do a se přiřadí hodnota) součtu b a c. Z věcí, které by ještě nemusely být úplně jasné: znak pro násobení je *, znak pro dělení je /. Přitom můžete mezi sebou míchat celá čísla i čísla s desetinnou čárkou, převod proběhne automaticky.
Dnešní jednoduchý program /* druhy program! pocitani pokut */ #include<stdio.h> int main() { //tady zacina hlavni blok kodu //tady zacina nas program printf("Vytejte v programu, ktery vypocitava pokuty!\n\r"); printf("Pokuty se budou strhavat ze standardniho platu 15000Kc!\n\r"); //nadeklarujeme 3 promenne typu int int standardni_plat; int snizeny_plat; int pokuta; //nastavime pocatecni hodnoty standardni_plat = 15000; pokuta = 400; //spocitame kolik je snizeny plat; odecteme tedy od promenne standardni //plat, ktera ma hodnotu 15000, promennou pokuta, ktera ma hodnotu 400. //15000-400 je 14600, tzn. ze do promenne snizeny plat se nam ulozi //hodnota 14600 (prace s ostatnimi druhy promennych probiha stejne) snizeny_plat = standardni_plat - pokuta; //vypiseme hodnotu snizeneho platu //POZZ: funkce printf ma promenny pocet parametru, je trochu nestandardni, //ale velmi sikovna printf("Zlobivy zamestnanec si vydela jen %d", snizeny_plat); //pockame na stisk enteru getchar(); //to neni dulezite return 0; } //tady konci hlavni blok kodu
Platnost proměnných Používat proměnnou můžete až potom, co jste jí nadeklarovali. Jenomže proměnné taky mohou "umřít". Celá zápletka je v tom, že proměnná je platná jen v té části kódu, ve které je deklarovaná. Nás zatím tohle umírání nemusí tížit a když na to nezapomenu, zmíním to v příštím díle.
Do příště Zkuste si upravit program tak, aby se standardní plat kvůli mimořádným úspěchům firmy zvednul dvakrát (jinak než tak, že místo 15000 napíšete 30000!). Nápověda: platí stejná pravidla (přednost násobení a dělení před sčítáním a odčítáním) jako u normálních počtů a můžete používat závorky.
Programování v C/C++ 4. díl Dnešní téma je větvení a podmínky. Tu slibovanou hru budeme muset ještě o jeden díl odložit, ale přijde. Minule jsem se tu rozepisoval o proměnných. Doufám že si ještě pamatujete co je to char, short, long, int, double a float. Ani nepředpokládám, že si je pamatujete všechny, ale aspoň polovinu by jste si pamatovat mohli.
Blok kódu Takovým předpokladem pro dnešní téma je vědět, co je to blok kódu. Název není úplně přesný, prostě je to blok, blok kódu, blok programu nebo to mezi složenými závorkami. Představte si, že máte několik papírů. Aby se Vám s nimi lépe pracovalo, procvaknete je sešívačkou. Co je pro nás důležité je, že ta sponka ze sešívačky jednotlivé papíry spojila. Už nepracujete s jednotlivými listy, ale se všemi jako s celkem. Podobně funguje i blok kódu, vezme více řádek a můžete s nimi pracovat jako s jednou. Asi tady budu muset být přesnější. Jestli si ještě vzpomínáte, jak jsem říkal, že každý jednotlivý příkaz nebo funkce se musí oddělovat středníkem. Celý takový blok kódu se pak v programu chová jako jeden příkaz. Takový blok pak může vypadat například nějak takto. { //pozdravime printf("Ahoj, jak se dari"); } Do bloku je možné vkládat libovolně další bloky (což bude potřeba při větvení). Vkládat ale takový blok samoúčelně, pokud nepotřebujete seskupit více příkazů/funkcí, není standardní postup a ani bych to nedoporučoval, ačkoliv to není v zásadě špatně. Taky si v našem dnešním zkušebním programu nebo v ukázkovém programu z druhého dílu všimněte, že tam jeden blok kódu máme (v dnešním příkladu jsem ho označil). Je to takový hlavní blok v programu, na jeho začátku program začíná a na jeho konci program končí.
Větvení programu Může nastat situace (a ona nastane, a mnohokrát), že Váš program se v jeden moment zastaví na křižovatce a bude se muset rozhodnout, jestli odbočí nebo bude pokračovat rovně. Přijde na tu křižovatku, stojí tam a rozhodne se, kterou cestou půjde. To je větvení. Váš program dojde na nějakou svou řádku a tam se rozhodne, co bude dělat. Doufám, že už se ptáte, podle čeho se rozhodne. Rozhodne se podle nějaké podmínky. Například pokud uživatel zadal, že je vyšší než 180 cm, pochválíme ho za jeho výšku. Takovéto jednoduché větvení se dělá pomocí takového kouzelného slovíčka if (v angličtině if = pokud). Podmínku potom napíšeme do závorek hned za tohle kouzelné slovo a to, co se má vykonat hned za to (opět si všimněte, jak kód upravuji, aby se dobře četl) if( vyska > 180) printf("Ty si ale veky clovek"); Výše uvedený úryvek kódu by vzal hodnotu proměnné vyska (která byla samozřejmě někde dříve v programu použita a nastavena) a pokud by ta hodnota byla větší než 180, vypsala by se na obrazovku zpráva. Co když ale chceme provést více věcí než jenom jednu? Jednou možností by bylo napsat jedno if pro každou funkci, kterou chceme vykonat, pokud je podmínka splněna. Tudy ale cesta rozhodně nevede. Cesta naopak vede přes bloky kódu. Názorná ukázka if( vyska > 180 ) { printf("Ty si ale velky clovek…Jestli chces pokracovat, stiskni klavesu"); getchar(); printf("Jedeme dal"); } Zde, pokud je hodnota proměnné vyska vyšší než 180 (pro ty matikou nepoznamenané, > znamená větší než), program opět vypíše gratulaci, počká na stisk klávesy ENTER a informuje nás o tom, že program dál pokračuje. Pokud se podmínka nesplní, to znamená pokud jsme menší než 180 cm nebo máme přesně 180 cm, program pokračuje za funkcí nebo blokem, který následuje za slovem if. Připravil jsem vám dva diagramy, program pokračuje po šipkách.
pokud je hodnota proměnné vyska vyšší než 180
pokud je hodnota proměnné vyska menší než 180 V podmínkách můžete použít několik tzv. operátorů, lidštěji řečeno "značek". Operátor
Komentář
>
levá strana větší než pravá
<
pravá strana větší než levá
>=
levá strana vetší nebo rovna pravé
<=
pravá strana větší nebo rovna levé
== !=
levá strana se rovná pravé (POZOR - jsou to skutečně dvě =, zatímco dvě = porovnávají, jedno = přiřazuje hodnotu! levá strana se nerovná pravé
Říká se, že každý takový operátor má dva operandy. Jinými slovy každá ta značka potřebuje dvě čísla, které bude porovnávat. Když počítač uvidí nějakou takovou podmínku, nejprve si spočítá (vyhodnotí) číslo vlevo a vpravo od operátoru a potom je teprve porovnává. if( 10 - 2 > 3 ) je tedy ekvivalentní if( 8 > 3) Pokud se podmínka, kterou jsem napsali, splní, říká se, že se podmínka vyhodnotila jako pravdivá a nahradí se jedničkou (nenulová hodnota, nejčastěji 1, pro počítač znamená pravda, 0 pro počítač znamená nepravda). Pokud se podmínka nesplní, to znamená že hodnota proměnné výška je menší nebo rovna 180, potom se vyhodnotí jako nepravdivá a nahradí se nulou. Počítač tedy vlastně jenom zajímá, jestli je v závorce za if nula nebo jiné číslo. Pokud je tam nula, znamená to pro něj nepravda, pokud je tam jiné číslo, znamená to pravda a vykoná to, co je za if a závorkou. Pokud bychom měli podmínku, která vypadá zhruba takto if( 10 > 5 ) počítač to "vidí" jako if(1) Přeloženo do češtiny: Pokud je to pravda (…něco udělej…). Určitě vám hodně pomůže, když si budete takhle podmínky číst. (nahrazení jedničkou nebo nulou probíhá samozřejmě až za běhu programu, protože v době, kdy program píšete ještě neznáte hodnotu proměnné, která se objeví v podmínce) Pokud, v zájmu například lepší srozumitelnosti kódu, nebo i z jiných důvodu, potřebujete hodnotu otočit (udělat z pravdy nepravdu nebo z nepravdy pravdu), potom stačí před hodnotu, kterou chcete otočit, napsat vykřičník. if(!(18 > 15)) Což by znamenalo "pokud 18 není větší než 15". Vyhodnotilo by se to na: if(!(1))
Vykřičník nám pravdu (jedničku) otočí na nepravdu (nulu). if(0) A máme to.
Co když potřebuji více podmínek: Pokud je potřeba, aby bylo splněno více podmínek, můžete do závorek za if uvést podmínek i více. Mezi jednotlivými podmínkami je potřeba určit vztahy. Pokud mají být splněny obě podmínky, napíšete mezi ně &&, což se čte jako "a zároveň". Pokud vám stačí, aby byla splněna alespoň jedna podmínka, napíšete mezi ně || (dvě svislítka), což se čte jako "nebo". if(stari >= 17 && stari <= 25) printf("Chlap mezi 17 a 25, to je presne to co hledam :) "); "nebo" mezi podmínkami if(pocet_nohou > 2 || pocet_rukou > 2) printf("Ty asi nebudes clovek, ze ne?"); &&
A ZÁROVEŇ
||
NEBO
Pokud je levá i pravá strana pravdivá pokud je levá nebo pravá strana pravdivá, nebo jsou pravdivé obě
Ještě jednou zdůrazním, že u "nebo" stačí jen jedna ze dvou podmínek pravdivá, ale mohou být pravdivé i obě!). Pokud máte více podmínek než dvě, obzvláště pokud ještě k tomu kombinujete && a ||, dávejte velký pozor na to, v jakém pořadí se vyhodnocují a radši si vždy pomozte dalšími závorkami. Jednotlivé || a && se vyhodnotí opět jako pravdivé nebo nepravdivé a z if((1 && 1) || 0) se stane (vyhodnotí se nejprve závorka, 1 && 1, tedy "pravda a zároveň pravda", což je pravda, nebo-li pro počítač 1). if(1 || 0) z čehož se dále stane (alespoň jedno z dvojice pravda a lež je pravda, což je pravda, tedy 1) if(1) Pokud jste tím vším trochu zmateni, nic si z toho nedělejte. Pokud budete schopni lidskou větu správně přeformulovat na počítačovou podmínku, jste za vodou.
Další kouzelné slovo: else Pokud chcete, aby se, pokud je podmínka pravdivá, něco vykonalo a pokud ne, vykonalo se něco jiného, nemusíte použít dvě "opačné" podmínky. Stačí za funkci nebo blok, který máte za vaším if, dát slovíčko else a za něj hned funkci nebo blok, který nebo která udělá to, co chcete udělat, pokud je podmínka nepravdivá if(vek >= 18) //vykona se pokud je podminka spnena printf("Plnolety(a)"); else //vykona se pokud je podminka nesplnena pritnf("Neplnolety");
Zkušební program pokud si chcete osahat práci s podmínkami více, upravujte si podmínky v následujícím programu. #include<stdio.h> int main() //tady zacina nas hlavni blok! { /* tuhle podminku si muzete zkusit upravovat. zkousejte menit hodnoty a operator a zkuste také slozitejsi podminky s && a || */ if(10 > 5) printf("podminka splnena"); else printf("podminka nesplnena"); getchar();
//toho si nevsimejte return 0; } //tady konci hlavni blok
Dodatek o platnosti proměnných Jak jsem slíbil v minulém díle, zmíním se tu ještě krátce o platnosti proměnných. Proměnná platí do konce bloku, ve kterém je deklarována, ale platí i v blocích vnořených v jejím bloku
Programování v C/C++ 1. bonus První bonusový díl je tady a s ním naše první hra. I když ještě nejsme schopní napsat celý program úplně sami, určitě budeme schopni ho napsat s trochou nápovědy.
Pravidla Naše hra bude hodně jednoduchá: hádání čísla. Doufám, že teď nejste zklamaní, ale pořád jsme jen začátečníci, že? Pravidla jsou jednoduchá. Počítač si myslí náhodné číslo od 1 do 100 a uživatel hádá, jaké to je. Pokud uhádne, počítač mu pogratuluje a program se ukončí. Pokud uživatel hádal číslo menší, řekneme mu, že hádané číslo je větší. Naopak pokud bude hádat větší, upozorníme ho, že hádané číslo je menší.
Jak na to? Ještě než začneme, položím vám otázku: jak by asi měl program podle vás vypadat, jakou by měl mít strukturu (jaké konstrukce/smyčky by jste použili, jaké proměnné a co budou vyjadřovat)? Zkuste si na tuto otázku odpovědět, klidně si dejte i chvilku na rozmyšlenou.
Plán Já jsem se rozhodl pro 3 proměnné. Jednu, která bude uchovávat naše hádané číslo, jednu, která si bude pamatovat, co uživatel zrovna tipoval za číslo a jednu, která nám bude pomáhat s hlavní smyčkou v programu. //do teto promenne ulozime cislo, ktere si pocitac vymysli int hadane_cislo; //do teto promenne ulozime cislo, ktere uzivatel zadal int uzivatel_zadal; //ma program pokracovat nebo uz uzivatel uhadl? int pokracuj; Co se týče smyček, rozhodl jsem se pro jednu hlavní while smyčku. Váš návrh může vypadat samozřejmě jinak, dovedu si například představit i řešení s do…while smyčkou. Nic Vám nebrání si to zkusit napsat podle svého. To samé platí i pro vaše proměnné. V podmínce této mé smyčky se bude vyhodnocovat proměnná pokracuj. Pokud bude mít hodnotu 1, bude se dál pokračovat, pokud bude mít hodnotu nula, smyčka se sama ukončí. while(pokracuj == 1) { //tady bude vlastni kod }
Příprava na smyčku Ještě než ale začneme se smyčkou, je potřeba nastavit naše proměnné na správné hodnoty. Například pokracuj musíme nastavit na 1, protože jinak by se nám nevykonal ani jeden cyklus naší smyčky. Potom je potřeba ještě do hadane_cislo uložit nějaké náhodné číslo… o to se postarají dvě následující řádky //trocha magie, tohle jeste neumime srand((unsigned)time(NULL)); //do hadane_cislo ulozime pocitacem vygenerovane nahodne cislo //teto radce take jeste asi nerozumite hadane_cislo = rand()%100 + 1;
Smyčka Ve vlastní smyčce potom vždy přečteme číslo od uživatele //tato radka precte od uzivatele cislo //zatim budeme predpokladat, ze uzivatel skutecne //zada cislo a nebude se snazit vnutit nam nejaka pismenka scanf("%d", &uzivatel_zadal); a třemi if-y potom zjistíme, jestli je číslo menší, větší, nebo jestli uživatel uhádl. Zkuste si program opravdu napsat sami, pasivní znalost je poloviční znalost.
Kód Zde příkládám funkční kód této hry. Pokud chcete hru trochu vylepšít, zkuste ji upravit tak, aby měl uživatel na uhádnutí čísla jen několik pokusů. #include<stdio.h> #include<stdlib.h>
#include
int main() { //do teto promenne ulozime cislo, ktere si pocitac vymysli int hadane_cislo; //do teto promenne ulozime cislo, ktere uzivatel zadal int uzivatel_zadal; //ma program pokracovat nebo uz uzivatel uhadl? int pokracuj; //nastavime nase promenne pokracuj = 1; //trocha magie, tohle jeste neumime srand((unsigned)time(NULL)); //do hadane_cislo ulozime pocitacem vygenerovane nahodne cislo //teto radce take jeste asi nerozumite hadane_cislo = rand()%100 + 1; //dokud je pokacuje rovno 1 while(pokracuj == 1) { //ptame se uzivatele na cislo mezi 1 a 100 printf("hadej cislo od 1 do 100\n\r"); //tato radka precte od uzivatele cislo //zatim budeme predpokladat, ze uzivatel skutecne //zada cislo a nebude se snazit vnutit nam nejaka pismenka scanf("%d", &uzivatel_zadal); //pokud uzivatelem zadane cislo je vetsi nez to, ktere //si mysli pocitac if(uzivatel_zadal > hadane_cislo) printf("kdepak, hadane cislo je mensi…\n\r"); //pokud uzivatelem zadane cislo je mensi nez to, ktere //si mysli pocitac if(uzivatel_zadal < hadane_cislo) printf("kdepak, hadane cislo je vetsi…\n\r"); //pokud uzivatele zadane cislo je rovno cislu, ktere //si mysli pocitac if(uzivatel_zadal == hadane_cislo) { //pogratulujeme printf("Uhadl jste!\n\r"); //nastavimje pokracuj na 0, to ze while-smycka //se, hned jak se dojde zpet k while, ukonci pokracuj = 0; } } //rozloucime se printf("nashledanou"); //pockame na ENTER getchar(); //tajemna radka return 0; }
Programování v C/C++ 5. díl Začneme už trochu tradičně opakováním. Naposledy jsme se seznámili s větvením programu a podmínkami. Doufám, že jste vše náležitě pochopili, protože dnes na předešlé téma navážeme. Co je podmínka, a jak se zapisuje, už jsme se naučili a dneska si probereme ty zbylá kouzelná slova, co nám pomáhají řídit, kudy se program ubírá.
WHILE While je dneska první na řadě. Zapisuje se takhle while(podmínka) příkaz; A říká počítači, že dokud je podmínka v závorce pravdivá, má vykonávat příkaz, který je za závorkou uveden. Pokud jste pozorně četli minulé díly, tušíte správně, že příkaz můžete samozřejmě nahradit i blokem kódu (to, že se může příkaz nahradit blokem kódu, už budeme brát za samozřejmé a nebudeme to znovu zmiňovat). V praxi while (anglicky „dokud (je pravda)“) použijete velmi často. Program totiž často dělá něco dokola a dokola. Program počká, co po něm uživatel chce, provede to a znovu čeká. To se děje právě v tomto while . Mimochodem, často se také říká smyčka, což značí právě to, že vždy, když se program dostane na konec bloku, vrátí se zase na jeho začátek (pokud je splněna podmínka; v naprosté většině případů se za while používá blok kódu). Praktickým příkladem pro while je následující úryvek kódu: int cislo; cislo = 0; //program o sobe neco napise printf(“pocitani do 99\n\r”); //dokud je hodnota promenne cislo mensi nez 100, vykonej blok kodu while( cislo < 100) { //zvetsime cislo o 1 cislo = cislo + 1; //vypiseme ho printf(“%d \n\r”, cislo); } Program deklaruje proměnnou cislo, nastaví ji na nulu a potom začne smyčka. V ní se nejprve vyhodnotí podmínka. Pokud je pravdivá, přejde program do bloku kódu a k proměnné cislo přičte 1, a vypíše se. Potom se program vrátí zpátky na řádku s while a začne se opět porovnáním podmínky. Všimněte si, že pokud je podmínka nepravdivá, nemusí se vykonat ani jeden cyklus smyčky. Pokud je podmínka splněna, vykoná se smyčka, pokud není, nevykoná a program pokračuje za ní.
Variace na while Takovou sestřičkou while je tzv. do…while . Chová se naprosto stejně jako while, akorát podmínka se vyhodnotí až po provedení smyčky, nikoliv na jejím začátku. Zapisuje se: do příkaz while(podmínka); Na rozdíl od samotného while je tady navíc slovo do (anglicky „dělej“) a while je až na konci. Nejprve se vykoná blok kódu. Potom se vyhodnotí podmínka. Je-li pravdivá, celé se to opakuje. Pokud nepravdivá, program pokračuje normálně dál. Žádná velká věda.
Smyčka for Občas potřebujete něco udělat přesně několikrát. Třeba třikrát pípnout. Potom se používá tzv. for-cyklus, který se zapisuje for(nastavení proměnné; podmínka; co se s proměnnou v každém cyklu provede) příkaz; Ano, v závorce jsou tři části oddělené dvěma středníky. Je to o trochu složitější, než bylo while, takže rovnou uvedu praktický příklad. int i; for(i = 0;i < 3;i = i + 1)
{ //fiktivni funkce ktera pipne pipnout_prosim(); } Tento kód ze všeho nejdřív nastaví proměnnou i na 0. Potom se vyhodnotí podmínka. Pokud je pravdivá (tedy i je menší než tři), provede se blok kódů (zde bych ani blok kódu použít nemusel, ale udělal jsem to, aby byl kód lépe čitelný). Na konci takového bloku kódu se provede poslední část závorky, tedy i = i + 1. Jinými slovy: i se zvýší o jedu. Je samozřejmě na Vás, jaké počáteční hodnoty zvolíte a jestli budete přičítat jedničku nebo například odečítat trojku. Nakonec se počítač vrátí zpátky k for, zjistí, jestli je podmínka stále pravdivá a znova se začne vykonávat blok kódu. Určitě si někteří z vás všimli, že to samé můžeme zapsat i pomocí while . Ano, můžeme (pod odstavcem jsem to udělal, aby jste se měli čeho chytnout). Ale for-cyklus se používá, protože pak každý hned pozná už z prvního řádku (protože tam je ta důležitá závorka), co taková smyčka dělá a nemusí hledat v bloku kódu, kde se která proměnná mění atp. int i; //i musime nastavit na nulu i = 0; //pokud je i mensi nez 3 while(i < 3) { //fiktivni funkce, ktera zaridi pipnuti pipnout_prosim(); //k i pricteme 1 i = i + 1; } Proměnné (v tomto případě i; většinou se používá, potřebujete-li do sebe vnořit více for-cyklů, proměnných s názvy i, j, k atd., ale můžete je s klidným svědomím nazvat, jak chcete), která počítá počet cyklů, (kolikrát se vykonal blok kódu za závorkou) se říká čítač.
Učíme se číst Hodně vám pomůže, když se naučíte „číst“ tyto konstrukce. Zkuste si to trochu osvojit, obzvláště pokud máte s touto látkou problémy. Jako bonus i pár řádek k minulé hodině. while (i > 3) { //nejaky kod }
dokud je i větší než tři, vykonávej blok kódu
while (teplota_vody <= 100) { //nejaky kod }
dokud je teplota_vody menší nebo rovna stu …
do { //nejaky kod } while (i >= 100 && i =< 200)
vykonávej blok kódu dokud i je větší nebo rovno stu a zároveň i je menší nebo rovno dvěma stům
for (i = 0;i < 25;i = i + 1)
pro i rovno nule přičítej v každém cyklu jedna, dokud i je menší než 25
if (!(cislo == 0))
pokud neplatí (to je ten !), že se cislo rovná nule
if (cislo < 18 || cislo == 25)
pokud je cislo menší než 18 nebo je cislo rovno 25
Shrnutí Teď už víme, co je to while, do…while a for-cyklus. Všechno jsou to stále důležité věci, takže experimentujte. S dotazy se, jako obvykle, můžete obracet do diskuse pod článkem. Slibovanou hru si napíšeme v bonusovém díle, který by vychází společně s tímto.
Programování v C/C++ 6. díl Po trochu delší odmlce je tu opět další díl našeho seriálu. Doufám, že si ještě něco pamatujete a že jste případně sami trochu pokročili. Každopádně naším dnešním cílem je povědět si něco víc o tom, jak ještě fungují funkce a kde všude se dají použít.
Vyhodnocování výrazů Vezměte si například, takovou matematickou funkci abs (tedy absolute - je to funkce, která vrátí absolutní hodnotu z nějakého celého čísla, jednoduše pokud je číslo záporné, změní jeho znaménko na plus, pokud už je kladné, nedělá nic). Pokud bychom měli nějakou proměnnou a chtěli si do ní uložit právě absolutní hodnotu, dá se to, jak už všichni nejspíš víte, udělat asi takhle: //promenna cislo, do ktere se bude ukladat nase obsolutni hodnota int cislo; cislo = abs(-5000); Je jasné, že do proměnné číslo se uloží hodnota 5000. I když si myslím, že už to většina z vás okoukala, přeci jenom to ještě trochu dovysvětlím. Program běží a dostane se na naši řádku s funkcí abs. Protože do proměnné cislo se má uložit hodnota z "druhé strany rovná se", tj. výsledek funkce abs, vyhodnotí se, jakou hodnotu vrací funkce abs s daným parametrem a ten se uloží. To je samo o sobě docela zřejmé a chápatelné. Z toho ale také vyplývá, že místo čísla můžete kdekoliv použít i nějakou funkci, která číslo toho druhu vrací. Můžete je tedy například použít i u podmínek (pokud si budete chtít kód otestovat, na začátek programu přidejte ještě řádku #include ) int hodnota; hodnota = -30; //ne zrovna ukazkova podminka na zjisteni toho, jestli //je cislo kladne nebo zaporne if(hodnota == abs(hodnota)) { printf("cislo je kladné!"); } To platí samozřejmě i například u while a jiných. Nebojte se experimentovat. Funkci můžete použít i jako parametr jiné funkce, opět je ale potřeba dbát na to, aby byla zachována přehlednost kódu. Pokud bude váš kód vypadat takhle: a(b(), c(), d(e(), 10), f()); moc z něj asi nevyčtete. Navíc si dávejte pozor, aby funkce, které dáváte jako parametr, nebyly extrémně paměťově náročné (snad se o tom zmíním někdy později, ale bývají to jen vyjimečné případy). Taky si všimněte, že když je funkce takhle někde "zabudovaná", nepíšeme za ni středník. Jestli si pamatujete, mluvili jsme o tom, že středník odděluje jednotlivé funkce/příkazy. Tady ale chápejte celou tu konstrukci (ať už je to funkce co má za parametr nějakou další funkci nebo podmínka nebo něco jiného) jako jeden příkaz.
Líné vyhodnocování Má to ale ještě jeden háček. V C/C++ se totiž uplatňuje tzv. líné vyhodnocování. Jakmile je jasné, že podmínka nemůže být splněna, přestane její vyhodnocovaní. Například při if(abs(0) && abs(-1)) je hned po vyhodnocení abs(0) jasné, že podmínka nemůže být splněna (&& - AND - a zároveň… obě strany musí být pravdivé, abs(0) je rovno 0, tj. nepravda, z toho plyne, že podmínka nemůže být splněna). Vyhodnocování tedy skončí a abs(-1) se už neprovede! To se vám může stát osudným, pokud by jste ve funkci, která je v podmínce, vykonávali ještě nějakou důležitou činnost, např. if(NahrajZvuky() && NahrajGrafiku()) { printf("zvuky i hudba v poradku nahrany"); } Zde by stačilo, aby chyběly zvukové soubory (které ale třeba nejsou k běhu hry/programu vůbec potřeba a uživatel si je nestáhl) a nenahraje se ani grafika (která už je k běhu programu většinou potřeba). Dávejte si na to pozor. To samé platí i u ||, jakmile je jedna část podmínky pravdivá, je jasné, že je podmínka splněna a druhá část se nevykoná/nevyhodnocuje. Těchto vlastností můžete využít ve svůj prospěch, ale můžou vás i stát hodně nervů. Pokud to vyřešíte jiným způsobem, nikdo vám to nebude mít za zlé. Navíc by to opět udělalo váš program čitelnější. Pokud se tedy
rozhodnete nějaké podobné vlastnosti použít, nezapomeňte se o tom zmínit v komentářích, tohle není úplně běžně používaná konstrukce.
Funkce Po takovém opakovacím a upozorňovacím začátku bych se rád pustil do funkcí. Když si představíte, že celý Váš program (zrovna například píšete třeba průlomový operační systém) je napsaný tak, jako ho píšeme doteď …. int main() { //tady tisíce různých řádek return 0; } měli by jste se zhrozit. Samozřejmě spousta začátečníků píše programy podobně "v kuse". To se hodí pro krátké utilitky nebo jiné menší programy, ale rozhodně už ne ani pro většinu normálních aplikací. Program totiž můžeme šikovně rozdělit na spoustu menších dílů (funkcí/procedur). Každá funkce se potom stará o nějakou specifickou činnost a když potřebujeme takovou činnost vykonat, prostě "zavoláme" příslušnou funkci a ona to vykoná za nás. Tady bych rád podotknul, že s jazykem C/C++ je "přibalena" už i spousta předpřipravených funkcí. Z těch, se kterými jsme se už seznámili to jsou např. printf, getch nebo o pár odstavců výše uvedené abs. Je mnoho případů, kdy se hodí kus programu "vyříznout" a dát do funkce. Třeba když některou činnost v programu často opakujete nebo když se jedná o rozsáhlý kus kódu, který by nemusel působit přehledně (i když je v celém programu jen jednou) a vám by se hodilo celou tu velkou hrůzu někam schovat. Typickým příkladem nějaká rozsáhlá inicializace programu, kde se nahrává spousta věcí ze souboru atp. Je lepší to schovat do nějaké funkce a pak jen zavolat nahraj_vse_potrebne_a_nastav_promenne(); Pro často opakující se kus kódu by příkladem mohla být například naše matematická funkce abs. Ta může být potřeba v programu na různých místech nesčetněkrát (tedy v nějakém matematickém programu). Protože už jste s funkcemi pracovali (volali jste je když jste potřebovali počkat na stisk klávesy nebo něco vypsat na obrazovku), měli by jste vědět, že funkcím lze dávat parametry a taky že nám funkce mohou vracet hodnotu.
V praxi Dost teorie, ukážeme si konečně, jak se taková funkce definuje (definuje znamená, že píšeme, co má funkce dělat) typ_navratove_hodnoty jmenofunkce(typ_parametru jmeno_parametru, typ_parametru jmeno_parametru, …., typ_parametru jmeno_parametru) { //tady je vlastni kod funkce } pozn: ano, poznali jste, main je také funkce… je to funkce, která se pustí po začátku programu a chová se v mnoha věcech trochu podivně Typ návratové hodnoty je prostě to, co chcete vracet. Může to být float, int, char nebo jiné typy, se kterými jsme se už seznámili. Pokud nechcete vracet hodnotu, potom je návratový typ void (anglicky prázdnota). Následuje jméno funkce, například tedy MojePrimovaFunkce (jméno se řídí stejnými pravidly jako jména proměnných). Za ní obyčejné závorky () a v nich jednotlivé paramtery oddělené čárkou (pokud žádné parametry nechcete, jsou to jen prázdné závorky; u parametru je vždy nejprve jeho typ a pak jeho jméno) například: void ahoj(); int SpocitejVekVeDnech(char den_narozeni, char mesic_narozeni, int rok_narozeni); char je_cislo_mocinou_dvojky(int cislo); Určitě vás už zajímá, jak se ve funkci přistupuje k parametrům. Úplně stejně, jako by to byla proměnná (která má ale platnost jen uvnitř funkce, ona to také je proměnná… kompilátor za vás totiž vytvoří pro každý parametr odpovídající proměnnou a do ní uloží hodnotu, která byla funkci předána). Z toho vyplývá, že cokoliv pak s parametrem/proměnnou uděláte, se projeví jen uvnitř funkce Takováto funkce by určitě nefungovala void pricti_jednicku(int cislo) { cislo = cislo + 1; }
Protože jak jsme si řekli, ve funkci pricti_jednicku se vytvoří proměnná cislo a k té se přiřadí hodnota 1. Zhruba takhle … { cislo = 1; cislo = cislo + 1; } Můžete ale hodnotu z funkce vrátit. Nejprve musíme uvést, že budeme hodnotu vracet int pricti_jednicku(int cislo) a pak ve vlastním bloku funkce (říká se těle funkce, tedy ve vlastním těle funkce) příčteme k proměnné cislo jedničku a vrátíme. To se dělá pomocí slova return a za ním napsané hodnoty nebo proměnné. Slovem return (anglicky návrat) se ale funkce ukončí (návrat k hlavnímu programu). Opět, int pricti_jednicku(int cislo) { cislo = cislo + 1; return cislo; } V programu potom { int moje_promenna; moje_promenna = 1; //pricteme k moje_promenna jednicku moje_promenna = pricti_jednicku(1); //ted by se melo vypsat na obrazovku cislo 2 printf("%d", moje_promenna); } Už je toho celkem hodně. Dnes už na vás nebudu více nakládat. Jen si pamatujte, že parametr se zkopíruje/přiřadí do proměnné, kterou pro vás připraví kompilátor a s tou vy pak pracujete (jak to obejít si někdy ukážeme; ve funkci můžete přistupovat ke globálním proměnným (to jsou proměnné deklarované mimo tělo nějaké funkce - platí totiž v celém programu), ale není to vždy zcela dobrý přístup, obzvláště opět kvůli přehlednosti při používání ve více funkcích najednou). Dále že návratová hodnota se vrací před slůvko return a že se tak také ukončí funkce (pozn. když je návratový typ void, tedy nic, můžete funkci také ukončit předáním "žádné" návratové hodnoty: samotným return). Pokud si chcete látku trochu ozkoušet: Napiště funkci, která bude vracet absolutní hodnotu z čísla předaného v parametru řešení (funkce + vlastní program): #include #include #include int absolutni_hodnota(int cislo) { //pokud je cislo zaporne, vratime -cislo, tedy cislo * -1 if(cislo < 0) return -cislo; else return cislo; } int main() { int promenna; promenna = absolutni_hodnota(-5); printf("%d", promenna);
getch(); return 0; }
Programování v C/C++ 7. díl Po dlouhé době opět další díl (chtěl bych poděkovat především všem těm, kteří mne svými reakcemi přesvědčili seriál obnovit). Minule jsme si řekli jak vypadá funkce a něco o vyhodnocování výrazů. Pokud už si z toho něco nepamatujete, nebojte se zkonzultovat minulý díl. Lidé zapomínají, od toho je nápověda.
Dnešní téma Úkolem bude vysvětlit si, co je to preprocesor a k čemu a jak se využívá. V druhé půlce si představíme některé dosud neznáme operátory (znaménka).
Preprocesor a jeho direktivy V nějakém vašem programu jste už určitě narazily na řádky, které začínají #. Váš editor je odlišuje barevně nebo třeba tučnějším písmem, a já jsem vám zatím jejich výraz zatajil. Nazývají se direktivy preprocesoru. To je sice krkolomný název, ale nikdo vás přece nenutí si ho pamatovat. Jde o to, že ještě předtím, než přijde řada na samotnou kompilaci (kdy se tedy z vašeho .cpp souboru stává .exe), vezme počítač váš zdrojový kód a nechá ho předzpracovat právě preprocesorem (pre = před, procesor = "zpracovávač"). Ten podle toho, co jste za # napsali, s vaším programem něco provede.
#include<soubor.h> Vezme soubor s jménem, které jste uvedli mezi < a > a celý ho vloží na místo, kde je vaše #include< >. Tento soubor pak obsahuje zdrojový kód pro některé předpřipravené funkce, které můžete ve vašem programu použít. Často jsme vkládali soubory stdio.h, stdlib.h a conio.h.Právě ty obsahují některé funkce jako printf, getch atp.
#include"soubor.h" Liší se od #include< > jenom v tom, odkud soubory bere. #include< > je bere z adresáře, který je přednastavený ve vašem vývojovém prostředí, zatímco #include" " je bere z aktuálního adresáře. Zatím tuhle direktivu nebudete potřebovat, ale může se stát, že na ni narazíte.
#define JMENO HODNOTA Direktiva, se kterou budete pracovat asi velmi často. Preprocesor nahradí výskyt všech JMENO ve zdrojovém kódu slovem HODNOTA. To se používá, pokud máte nějakou hodnotu, která se v kódu často vyskytuje. Příkladem by bylo třeba řecké PI. #define PI 3.1415 … float vysledek; vysledek = sin(PI); … Hlavním účelem je, aby byl text přehledný. Obzvláště když píšete matematické programy nebo potřebujete počítat něco podle vzorce, můžete se dostat časem do situace, kdy už nevíte, co tohle nebo tamto číslo vlastně má znamenat a proč jste ho tam dali. Takhle ho můžete krásně pojmenovat. Dalším, ještě důležitějším účelem je potom to, že změnou jednoho řádku s #define změníte snadno všechny výskyty na jinou hodnotu. Například #define PRACOVNIKU 10 int rozpocet_na_platy; int i; rozpocet_na_platy = 100000; for(i = 0;i < PRACOVNIKU;i++) { … } printf("kazdy pracovnik dostane %d Kc", rozpocet_na_platy / PRACOVNIKU); Teď si představte, že potrebujete změnit ve vašem výpočtu počet pracovníků. Není nic snažšího, než místo #define PRACOVNIKU 10 napsat #define PRACOVNIKU 25 Můžete sice namítnout, že můžeme počet pracovníků uložit do proměnné, což je naprostá pravda. Ale jsou i případy, kdy se to nehodí (zmíním se o tom v některém z podějších dílů).
Další direktivy mezi další direktivy, na které můžete narazit, patří například jiné formy #define, #ifdef, #pragma apod. To jsou všechno věci, bez kterých se zatím rozhodně obejdete.
Některé další operátory Když jsme mluvily o operátorech jako +, -, * a /, vynechali jsme ještě některé jejich mutace (tohle už nejsou znaménka jak je známe z matiky, ale trochu nestandardní znaménka z programování… budeme jim prostě říkat nadále jen operátory). Kolikrát už jsme potřebovali přičíst k proměnné nějaké číslo, třeba 5? Zapisovali jsme to vždy jako char promenna; promenna = promenna + 5; Dá se to ale zapsat i daleko pěkněji. Potřebujete-li tedy některou proměnnou vynásobit, vydělit, zvětšit nebo zmenšit o nějakou hodnotu nebo nějakou hodnotou, můžete na to použít operátory z tabulky. Ty tu nejsou od toho, aby nám dodali nějakou novou funkčnost, ale aby nám usnadnili zápis našeho programu. nový operátor a += b a -= b a *= b a /= b
jinak zapsáno a=a+b a=a-b a=a*b a=a/b
čte se plus-rovná se; zvětšeno mínus-rovná se; zmenšeno krát-rovná se děleno-rovná se
Názvy jsou spíše nápověda, můžete je slyšet i pod jiným jménem. Tyto operátory se běžně používají a můžete je bez bázně a hany používat pořád (popravdě je to lepší, než psát delší formu, opět to totiž zvyšuje čitelnost programu).
Operátory -- a ++ Pokud potřebujete proměnnou zvětšit nebo zmenšit o jedna, můžete k tomu použít operátory ++ a -- (nic obdobného pro * a / neexistuje). a = 1; a++; printf("%d", a); //tady se vytiskne 2 Má to ale jeden háček, můžete totiž napsat jak a++; tak ++a; Rozdíl nastane, když by jste napsali (což už je celkem složité) a = 0; promenna = a++; a a = 0; promenna = ++a; V prvním případě se totiž promenna bude rovnat 0, v druhém 1. a++ totiž přičte k a číslo 1, ale "vrátí"-nahradí se hodnotou původního a. U ++a je to naopak. Také se zvětší o jedna, ale je nahrazeno už o jedna zvětšeným číslem místo čísla původního. Tedy Napíšeme-li promenna = a++, je to stejné, jako bychom napsali promenna = a; a += 1; Napíšeme-li promenna = a--, je to jako a += 1; promenna = a; Já osobně používám ++ a -- jen pokud potřebuji proměnnou zvětšit nebo zmenšit, ale ničemu ji nepřiřazuji, například for cykly jako int i; for(i = 0; i < cislo; i++) { …
} a podobně. Nedoporučuji (a to celkem silně) vám používání operátoru ++ a --, když chcete něčemu přiřazovat hodnotu, hlavně opět kvůli přehlednosti (a aby jste pak nehledali dlouho chybu, kolikrát už jsem kvůli vlastní lenosti strávil hodiny hledáním chyb). Může se vám stát, že to někde uvidíte.
Program Napiště program, který pro každého druhého pracovníka z 20 vypíše jeho číslo (nápověda: vypsat každého druhého vlastně znamená posouvat se při procházení o dva) #include<stdlib.h> #include<stdio.h> #include #define PRACOVNIKU 20 void main() { int i; for(i = 0;i < PRACOVNIKU;i += 2) { printf("%d\n", i); } }
Příště Přijdou na řadu tzv. pointery. To je jedna z nejdůležitějších věci (vše co bereme je důležité, ale pointery obzvláště) a bude potřeba jít malinko do nitra počítače a vysvětlit si, jak to funguje s pamětí.
Programování v C/C++ 8. díl Dnes načneme téma, které je nadmíru důležité a rozdělíme ho dokonce na několik článků. Tím tématem jsou ukazatele, nebo anglicky pointery (oba výrazy se používají).
Pointery Jak vypadá paměť Nejprve si řekneme, jak zhruba vypadá paměť v počítači (RAM). Ono nám ani tak nejde o to, jak ve skutečnosti vypadá, ale jak s ní pracujeme. Pro naše účely je tedy paměť spousta "políček" nebo "buněk", které jdou za sebou. Každé takové políčko je jeden byte [bajt]. Když to tedy shrneme, spousta políček o velikosti jednoho bytu za sebou. Co je to byte[bajt]: jednotka počítačové paměti. Skládá se z osmi bitu [bit], přičemž každý bit může být buď 1 nebo 0 (to jsou právě ty často zmiňované jedničky a nuly). Na úrovni bitů my ale pracovat nebudeme, budeme pracovat s byty. Každé to políčko má svoje číslo. Takovému číslu se říká adresa, nebo delším názvem adresa v paměti. Jako kdyby každá buňka paměti byl jeden obyvatel velkého sídliště :-).
Proměnné a paměť Každá proměnná musí být samozřejmě někde uložená v paměti. Mohli by jste se ptát, kolik té paměti nám sebere. Konkrétní velikosti jednotlivých druhů proměnných uvádím pro orientaci v tabulce. Nejsou ani tak důležíté, důležité je si uvědomit, že hodně z nich má přes 1 bajt. typ proměnné její velikost v bytech char
1
short, short int int, long, long int
2 4
float
4
double
8
podle operačního systému se velikost proměnných v bytech může lišit. Tato tabulka platí pro 32-bitové operační systémy jako Windows 95/98/NT/2000/Me a podobné, Linux a jiné Unixové sýstémy. Neplatí to ale například vždy v DOSu, kde jsou některé velikosti menší.
Stack a heap Kvůli některým vlastnostem pointerů je potřeba povědět si, co je to stack (tzv. zásobník) a co je to heap (tzv. halda). Já budu používat v článku anglickou terminologii, ale běžně se používá oboje. Obecně pro stack i pro heap platí, že jsou to místa v paměti, lépe řečeno kusy paměti, které jsou vyhrazené pro nějaký specifický účel a podle toho se odvíjí i jejich vlastnosti. Stack je kus paměti, který se vytvoří při startu aplikace (tedy ono je to trochu jinak, ale v zásadě). Ukládájí se na něj všechny proměnné, které ve funkci deklarujete (kromě globálních). Když jsme se bavili o parametrech funkcí, říkali jsme si, že se v těle proměnné vytvoří duplikáty proměnných, které jsme předali jako parametr. Ty se ve skutečnosti, stejně jako všechny proměnné vytvořené v těle funkce, přidají na stack. Když pak z funkce vyskočíte, zase se ze stacku umažou. S heapem už je to jednodušší. To je ta zbylá část paměti, kterou můžeme používat (sou i místa v paměti, které používat nemůžeme). Stack a heap se nepřekrývají, ale platí pro ně to stejné číslování adres. To znamená, že jsou vlastně v paměti na políčkách umístěny za sebou, ale jeden nemůže přerůst do druhého. V pravdě bývají jejich velikosti většinou pevné.
ilustrační schéma paměti (ve skutečnosti jsou políček miliony)
Pointery Teď už vám prozradím, co přesně je pointer. Je to vlastně úplně normální proměnná (identická s int, long nebo long int), a číslo, které jí přiřadíme, je adresa. Stejně jako normalní int se ukládá na stack a když se skončí funkce, ve které je deklarována, umaže se. Přesně jako každá normální proměnná.
Takový pointer tedy obsahuje adresu. Ta adresa nám ukazuje do paměti, na nějaké políčko (100 na 100. políčko, 101 na 101. políčko atp). Ale kompilátor ještě chce vědět, na co pointer ukazuje. Jestli na tom místě, na které ukazuje, leží (začíná) float, nebo jestli tam leží třeba char. To mu také musíme říct.
Jak se deklaruje pointer Pokud bychom tedy chtěli nadeklarovat proměnnou pointer, budeme postupovat takto typ_promenne_na_ktery_pointer_ukazuje *jmeno_promenne_tedy_vlastne_pointeru; Mnoho lidí pointery nepochopí, přitom je to snadné. Pointer (to, že je to pointer a ne obyčejná proměnná, značí právě ta * v jeho deklaraci) je vždy proměnná, která obsahuje číslo. Ta proměnná má v 32-bitových systémech jako Windows vždy velikost 4 byty (aha! 4 byty je 32 bitů!). To, na co ukazuje pointer, se překladači řekne na přes typ_promenne_na_ktery_pointer_ukazuje. Tohle je opravdu důležité, klidně si to pročtěte vícekrát, nesyďte se. Celé se to potom čte jako pointer na typ, konkrétně tedy třeba "pointer na float", "pointer na double" ap. int *pointer_na_int; float *pointer_na_float, *druhy_pointer_na_float;
Kam mohou pointery ukazovat Ne, že by pointery nemohli ukazovat na proměnné na stacku, ale jejich účelem je možnost ukazovat na heap, tedy mimo stack. Problémem stacku totiž bývá, že má často hodně omezenou velikost a proměnné se na něj tedy nevejdou (řekněme, že budeme schopni proměnných udělat tisíce) (když se zamyslíte, že pointer má 4 byty a většina proměnných stejně nebo míň, mělo by vám to přijít podivné nahrazovat malou proměnnou jako char třeba pointerem na char. To vysvětlíme v přespříštím díle)
Shrnutí Tahle lekce byla hlavně teoretická (z praxe jste se akorát dozvěděli, jak se pointer zapisuje). Nesnažte se zatím s pointery pracovat. Ještě zdaleka nevíte jak a taky by se vám mohlo stát (pokud by jste byli dostatečně zvídaví), že se vám povede "shodit" nebo "zaseknout" počítač. Měli by jste si být vědomi toho, co je to stack, že se na něj proměnné přidávají a ubírají se zněj a kdy (ty deklarované ve funkci se přidávají na začátku funkce, odebírají po jejím skončeni). Měli by jste vědět, že heap je nějaký kus paměti. Taky je dobré vědět, jak se zapisuje pointer a co to je.
Programování v C/C++ 9. díl Je tu dokončení minulého dílu o pointrech. Tentokrát už se dozvíme, jak se s pointery pracuje a co všechno se s nimi dá dělat. Na konci nastíníme i k čemu nám budou do budoucna.
Co je to alokace Posledně jsme si řekli, že pointer ukazuje kamsi do paměti. Ovšem my nemůžeme pointer vzít, přiřadit mu libovolnou adresu a na ni jen tak něco zapsat (jak se do poitneru přiřazuje hodnota a jak se poitneru přiřazuje adresa se dozvíte níže. Pokud vám dělá problém rozlišit tyto dva pojmy, přečtěte si znovu minulý díl). Problém by byl v tom, že náš pointer by potom ukazoval na nějaké místo v paměti, kde už mohou být uloženy různé věci. Co kdyby se vám povedlo ukazovat na místo, na které už ukazujete jinde (například když by jedna vaše funkce pracovala s nějakým místem v paměti a poté, o několik týdnu později, by jste dopsali jinou funkci, která by pracovala s tím samým místem paměti, jelikož vy už jste zapomněli, že s tímto místem pracujete)? Funguje to tak, že když chcete něco do paměti uložit, řeknete to systému a ten vám vyhradí určitý úsek z heapu. Současně s tím vám samozřejmě řekne, jakou adresu tento kus heapu má. Tedy chcete-li něco uložit do paměti: · řeknete to systému · systém vám řekne, na jaké adrese začíná pro vás vyhrazená paměť. Tomuto všemu se říká alokace. Vy tedy alokujete například jeden float a operační systém vám řekne, na jakou adresu ho můžete uložit. Stejně je to samozřejmě i s ostatními typy.
Jak se alokuje Když už víme co je to alokace, řekneme si ještě, jak se provádí. Protože víme, že nám systém vrátí adresu do paměti, musíme ji mít kam uložit. Když bychom chtěli uložit adresu například na float, napsali bychom float *poitner_na_float; Což tedy mluví samo za sebe. pointer_na_float je pointer, ve kterém je uložena adresa, která ukazuje na float. Teď když se zeptáme systému, kde bychom mohli svůj float uložit, bude to schematicky (new je anglicky nový, jako "nový kus paměti") nejky_pointer = new typ_na_ktery_bude_pointer_ukazovat; nebo s naším floatem poitner_na_float = new float; Systém teď ví, že má vyhradit paměť pro float, vyhradí ji (na heapu!! nikdy ne na stacku) a vrátí vám adresu na začátek tohoto kusu paměti, kterou vy si uložíte do pointer_na_float.
Dealokace Když už nepotřebujete daný kus paměti používat - taková situace nastává nejčastěji na konci programu - musíte zase systému říct, že už paměť nepotřebujete. Tohle by jste měli dělat vždy! Když to budete opomíjet, může se vám stát, že systému bude docházet pamět (protože vy jste systému neřekli, že už paměť nepotřebujete a on vám jí pořád drží rezervovanou). Je to jako kdyby jste nevraceli knihy do půjčovny. Za chvíli nebude co půjčovat. To je také důvod, proč jsem minule vysvětlil, co je to stack a co je heap. Protože pointer, jako každá normální proměnná, je na stacku, zatímco ty alokovaná data jsou v heapu. Jenomže to, že přestane existovat pointer ještě neznamená, že se odalokují data na heapu. Tohle v budoucnu využijeme ve svůj prospěch, tentokrát to ale uvádím, aby jste věděli, proč se má dealokovat. (důvodem k tomu, že se se zánikem pointeru automaticky nedealokují i data je ten, že na jednu adresu může ukazovat i více pointerů (což není špatně, pokud to tak chcete)) Syntaxe je následující (delete je anglicky smazat) delete nejaky_pointer; V našem případě tedy delete pointer_na_float; Měli by jste dealokovat jenom platné pointery (viz níže).
Práce s pointery Jak je nám známo, pointer je vlastně normální proměnná s hvězdičkou navíc, která uchovává adresu do paměti. Jak ale můžeme pracovat s pamětí, na kterou pointer ukazuje? Jak můžeme do pointeru přiřazovat adresy? Začneme naší druhou otázkou, tedy jak můžeme do pointeru přiřazovat adresy? Celkem jednoduše! Jako kdybychom chtěli do normální proměnné přiřazovat hodnotu. Tedy pointer = adresa; Než budu pokračovat, rád bych se zmínil o tom, že by vám kompilátor neměl dovolit přiřadit do pointeru číslo, které by vyjadřovalo adresu (no neměl, on vám to nedovolí), tedy například pointer_na_float = 456789; //tohle vám kompilátor nedovolí
Kompilátor by vám měl dovolit do pointeru přiřadit jen odpovídající typ pointeru, tedy pointer na float do pointeru na float, do pointeru na char pointer na char ap. float *pointer_1, *pointer_2; char *pointer_na_char; pointer_1 = pointer_2; //tohle jde pointer_na_char = pointer_1; //tohle je spatne! Tak to by byla práce s adresami. Ale co když chcete pracovat s tou proměnnou, na kterou pointer ukazuje? Dělá se to tak, že se v kódu před pointer napíše hvězdička: char *pointer_na_char; char normalni_promenna_typu_char; *pointer_na_char = 25; //tady je videt ta pridana hvezdicka normalni_promenna_typu_char = *pointer_na_char; //tady taky V prvním případě se do kusu paměti (tedy do proměnné typu char uložené na heapu), na který pointer_na_char ukazuje, zkopíruje hodnota 25. V druhém případě se hodnota proměnné, na kterou pointer_na_char ukazuje, zkopíruje do naší normální proměnné. Takový zápis s hvězdičkou pak kompilátor chápe stejně, jako kdyby jste pracovali s normální proměnnou, a čte se jako "to, na co ukazuje pointer na char", tedy například "to, na co ukazuje pointer na char, se rovná 25".
NULL a co je tam, když tam nic není?? Jediná číselná hodnota, kterou vám kompilátor dovolí do pointeru přiřadit, je 0. A to proto, že 0 je dohodou adresa, která je neplatná. Když tedy chcete říct, že pointer ještě na nic neukazuje, přiřadíte mu hodnotu 0. Místo 0 se ale píše NULL, kvůli přehlednosti, což je někde zapsáno jako #define NULL 0 takže je to vlastně to samé jako psát 0. Taky se vám při alokaci může stát, že new vrátí NULL. To znamená, že není dost paměti na heapu pro vaši proměnnou. Je dobrým zvykem kontrolovat, jestli se alokace opravdu povedla. Proč my ale vlastně přiřazujeme pointeru 0? Protože my nevíme, jaká adresa je v pointeru uložena. To je v postatě věc náhody, záleží to na tom co tam bylo předtím (když paměť byla používána jinou aplikací), jestli je zrovna úplněk a podobně. Tedy nic, co bychom dovedli předpovědět. Bude v tom něco naprosto náhodného. Proto je dobré nulovat (nebo NULLovat?;-)) pointery.
Když pointer ukazuje na stack Všechna alokovaná data jsou sice na heapu, ale to neznamená, že pointer nemůže ukazovat na stack! To on totiž může a celkem často se toho využívá. Kdybychom třeba chtěli (z důvodů, které osvětlím v nějakém pozdějším díle) předat jako parametr funkce pointer, ale programátor, který by naši funkci používal, by měl hodnotu uloženou jenom v normální proměnné, tedy na stacku. Když vy chcete pointer a on má jenom normální proměnnou, udělá se to tak, že vám dá adresu na svoji normální proměnnou, tedy na stack. Teď už by jste měli i vědět, proč by v žádném případě neměl zkopírovat hodnotu své proměnné do vašeho pointeru (krom toho, že to nejde nijak zapsat, když předáváme parametry funkci)… zamyslete se… protože vy od něj chcete pointer, tedy místo v paměti, ze kterého si budete "brát" svá data, a on se na nějakou úplně náhodnou adresu (viz výše - ten parametr samozřejmě obsahuje nějakou náhodnou adresu, tedy ukazuje na nějaké špatné místo) snaží něco nahrát. Vy chcete znát místo v paměti, ne zkopírovat do pointeru nějaká data. Z toho plyne, že vy ani ten pointer nealokujete! To jen tak mimochodem. Pokud ale chcete předat adresu na nějakou proměnnou (ve stacku): int *pointer_na_int; int normalni_int; pointer_na_int = &normalni_int; Napíšete před vaší normální proměnnou & a kompilátor ji v tomto zápisu bude vnímat jako pointer. Čte se to vše jako "adresa/pointer na normalni int", respektive "pointer na int se rovná adrese normálního int").
Shrnutí Naučili jsme se, co je to alokace, kde se nachází alokovaná data (heap), proč bychom měli dealokovat, že můžeme ukazovat i na stack, nejenom na heap. Dále také jak se dá pracovat s proměnou, na kterou máme pointer, i jak získat pointer na normální proměnnou.
Slušné chování Je pár zásad, které by jste vždy měli dodržovat. ·
Kontrolovat, jestli jste naalokovali v pořádku (když nebudete a uživatel si pustí k vašemu programu ještě film, bude něco stahovat atp. atp., vaše aplikace spadne).
· · ·
·
Odalokovávat jen platné pointery Vždy zapisovat jen do alokovaných pointerů Pokud používáte adresu na stack, být si jistý(á), že v době, kdy budete s obsahem proměnné, na kterou pointer ukazovat, pracovat, bude proměnná ještě stále na stacku. Tedy když přiřadíte pointeru adresu na nějakou proměnnou z dané funkce a budete s ní chtít pracovat poté, co funkce skončí, program spadne. Proměnná už totiž nebude na stacku, neboť funkce už skončila a všechny její proměnné se tedy vymazali ze stacku (viz minulý díl) být opatrní; když spadne program, je to na 90% kvůli práci s pointery.
Cvičení Napište program, kde budou tři pointery na int. Do prvního se uloží číslo, do druhého číslo a do třetího výsledek násobení. //nase tri pointery int *cislo1 = NULL, *cislo2 = NULL, *cislo3 = NULL; //pokud jsou platne, dealokuje poitnery void Uklid() { if(cislo1 != NULL) delete cislo1; if(cislo2 != NULL) delete cislo2; if(cislo3 != NULL) delete cislo3; } int main() { //naalokujeme cislo1 a zkusime, jestli se nam alokace opravdu povedla cislo1 = new int; //nepovedla, ukoncime program if(cislo1 == NULL) { //uklidime a ukoncime aplikaci Uklid(); return -1; } //naalokujeme cislo2 a zkusime, jestli se nam alokace opravdu povedla cislo2 = new int; if(cislo2 == NULL) { Uklid(); return -1; } //naalokujeme cislo3 a zkusime, jestli se nam alokace opravdu povedla cislo3 = new int; if(cislo3 == NULL) { Uklid(); return -1; } //ted uz mame vsechny tri pointery naalokovane, jdeme s nimi pracovat *cislo1 = 2; //priradime hodnoty *cislo2 = 3; //vysledek do cislo3 *cislo3 = *cislo2 * *cislo1;
printf("%d * %d = %d", *cislo1, *cislo2, *cislo3); Uklid(); } Jan Beneš
