Základy programování v jazyce C++ Doprovodný text 1. část

Základy programování v jazyce C++ Zpracoval Mgr. Michal Tarabec (SŠ-COPTH) pro kroužek programování Doprovodný text 1. část 1. díl... 2 2. díl... 5 3. díl... 11 4.díl... 16 5. díl... 23 6. díl... 27 7. díl... 32 8. díl... 37 9. díl... 41 10. díl... 46 11. díl... 49 Základy programování v jazyce C++ doprovodný text str. 1/52

1. díl Úvod do C++ C C++ C# Vývoj: od strojového jazyka, přes assembler (příkazy ADD, MOV), dále vyšší programovací jazyka jako Basic nebo Cobol (anglická slova). Interpret přeloží program při čtení a mění instrukce programového kódu přímo v konkrétní akce Kompilátor přeloží kód do podoby tzv. objektového souboru, který ještě není spustitelný (proces kompilace). Dále kompilátor spustí sestavovací program (linker), který objektové soubory sestaví do spustitelného programu. Interpretové jazyky ke spuštění programu vyžadují interpreter. U kompilované jazyky (C++) spustitelný program nevyžaduje kompilátor. Existují i interpretery C++ Program = 1. zdrojový kód (označení instrukcí vytvořených programátorem) 2. spustitelný software PROGRAMOVÁNÍ: 1. Procedurální (Sada přesně stanovených instrukcí, které se provádějí jedna po druhé) 2. Strukturované (Dělení větších úkolů na menší části; od složitějšího k jednoduššímu) 3. Objektově orientované programování (OOP) - Vymodelování objektů (reálných věcí) spíše než dat. Objekty, které modelujete, mohou být drobné prvky na obrazovce počítače jako tlačítka či okna se seznamem nabízených hodnot, nebo jimi mohou být reálné předměty jako kola, letadla, kočky či voda. - Objekty mají charakteristiky (rychlá, prostorná ) a schopnosti (zrychlit, letět ). Úkolem OOP je tyto objekty vytvořit v programovacím jazyce. C++ plně podporuje objektové programování včetně jeho tří pilířů: zapouzdření, dědičnost a mnohotvárnost (polymorfismus) Microsoft pro svoji platformu.net vyvinul jazyk C# (=90% jazyka C++) Bjarne Stroustrup = autor C++ dánský programátor a informatik, profesor na Texas A&M University http://www.research.att.com/~bs/ Základy programování v jazyce C++ doprovodný text str. 2/52

POSTUP PROGRAMOVÁNÍ 1. Analýza problému a jeho úplné pochopení 2. Tvorba návrhu = nalezení řešení 3. Volba vývojového prostředí 4. Zápis příkazů do zdrojového souboru.cpp 5. Vytvoření objektového souboru kompilátorem (překladačem), přípona.obj.o 6. Vytvoření spustitelného programu linkerem.exe V C++ se programy vytváří propojením jednoho nebo více objektových souborů.obj s jednou nebo více knihovnami. Knihovna je sbírka propojitelných souborů, které jsou buď součástí kompilátoru nebo je lze zakoupit, nebo je sami vytvoříme. Důležité znaky a klávesy Ctrl + Alt + < Ctrl + Alt + > Zkompilovat Ctrl + F9 Zkompilovat a spustit F9 Ladit F8 MŮJ PRVNÍ PROGRAM #include <iostream> std::cout << "Nazdar lidi!\n"; ODSTRANĚNÍ CHYB - Správná interpunkce - Podívat se do dokumentace Pokud výstupní okno spuštění.exe souboru ihned zmizí, dopište před příkaz return 2 řádky: char reakce; std::cin>> reakce; program čeká na zápis nějakého znaku Základy programování v jazyce C++ doprovodný text str. 3/52

Pro starší kompilátory za iostream doplňte.h (iostream.h) a vynechte předponu std:: VYTVOŘENÍ PROJEKTU 1. Zvolte: Soubor Nový Projekt 2. Zvolte: Console Application 3. Zadejte název projektu 4. Vyberte umístění projektu na disku a potvrďte 5. Do otevřeného souboru vložte zdrojový kód nebo ho zkopírujte z jiného souboru 6. Zvolte: Spustit Zkompilovat a spustit 7. Zadejte název spustitelného programu, který bude vytvořen. program bude přeložen a spuštěn Poznámky: Základy programování v jazyce C++ doprovodný text str. 4/52

2. díl Složení programu C++ Program v C++ je složen z objektů, funkcí, proměnných a dalších komponent. #include <iostream> direktivu # tzv. preprocesor najde příkazový řádek s křížkem ještě před spuštěním kompilátoru každý program v C++ má funkci main, funkcí rozumíme úsek kódu, který provádí jednu nebo více akcí, funkce main je volána po spuštění programu jako první. Funkce main v tomto případě bude vracet hodnotu typu int (číslo s celočíselnou hodnotou) všechny funkce začínají a končí závorkou a std::cout << "Nazdar lidi!\n"; tisk na obrazovku, objekt cout funkce vrací po svém skončení operačnímu systému celočíselnou hodnotu 0 std specifikátor oboru názvů říká, že objekt cout je součástí standardní knihovny << přesměrování výstupu \n zalomení řádku Vyzkoušejte používání objektu cout v následujícím programu: #include <iostream> std::cout << "Dobry den.\n"; std::cout << "Zde je cislo 5: " << 5 << "\n"; std::cout << "Manipulacni objekt std::endl "; std::cout << "zpusobi zalomeni radku na obrazovce."; std::cout << std::endl; std::cout << "Zde je velke cislo:\t\t" << 70000; std::cout << std::endl; std::cout << "Tady je soucet 8 a 5:\t\t"; std::cout << 8+5 << std::endl; std::cout << "A tady mame zlomek:\t\t"; std::cout << (float) 5/8 << std::endl; std::cout << "Zde je velmi velke cislo:\t"; std::cout << (double) 7000 * 7000 << std::endl; std::cout << "Nezapomente zmenit Jesse Liberty "; std::cout << "na vase vlastni jmeno...\n"; std::cout << "Jesse Liberty je programator C++!\n"; Základy programování v jazyce C++ doprovodný text str. 5/52

Příkazu cout musí předcházet příkaz #include <iostream> Manipulátor endl ukončí řádek (end line) \t znak tabulátoru, zarovnání Typy dat: Float desetinné číslo Double číslo s plovoucí desetinnou čárkou Místo toho, abychom před každým cout psali std:: použijeme dva příkazy: using std::cout; using std::endl; Tím řekneme kompilátoru, že budeme používat objekty cout a endl ze standardní knihovny. Pak stačí už napsat jen: cout << "Dobry den.\n"; Druhý způsob: using namespace std; Tím specifikuji celý standardní obor názvů. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ KOMENTÁŘE Používejte komentáře, za nějaký čas nebudete už vědět, proč zdrojový kód obsahuje ten či onen příkazový řádek!!! Komentář je text, který kompilátor ignoruje. - Jednořádkové // - Víceřádkové /* */ Základy programování v jazyce C++ doprovodný text str. 6/52

#include <iostream> using std::cout; /* toto je komentář a sahá až po ukončující značku hvězdičky a lomítka */ cout << "Nazdar lidi!\n"; // tento komentář končí s koncem řádku cout << "Komentar skoncil!\n"; // komentáře s dvojitým lomítkem mohou být na samostatném řádku /* stejně jako komentáře s lomítkem a hvězdičkou */ Komentáře by neměly říkat co se děje, ale proč se to děje, protože kód se mění a programátor může zapomenout komentář aktualizovat. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ F U N K C E Funkce (matematika) Funkce je v matematice název pro zobrazení z nějaké množiny M do množiny čísel (většinou reálných nebo komplexních), nebo do vektorů (pak se mluví o vektorové funkci). Je to tedy předpis, který každému prvku z M jednoznačně přiřadit nějaké číslo nebo vektor (hodnotu funkce). Někdy se však slovo funkce používá pro libovolné zobrazení. Funkci v programu musí být možné během programu zavolat. Výjimkou je funkce main(), která volá operační systém. Když funkce vykoná svoji práci, vrátí se program za místo, odkud byla funkce volána. Téměř každý program v C++ obsahuje funkce. Základy programování v jazyce C++ doprovodný text str. 7/52

Příklad funkce: #include <iostream> // funkce IlustracniFunkce // vytiskne velmi užitečnou zprávu void IlustracniFunkce() hlavička funkce (návratový typ+název funkce+parametry) std::cout << "Uvnitr Ilustracni funkce\n"; tělo funkce // funkce main - vytiskne zprávu, pak zavolá // ilustrační funkci a nakonec vytiskne // druhou zprávu std::cout << "Ve funkci main\n"; IlustracniFunkce(); std::cout << "Zpet ve funkci main\n"; Funkce vrací buď skutečnou hodnotu, nebo prázdnou hodnotu typu void. Vyzkoušej: Opiš programový kód: 1. Voláme funkci, která není definována. 2. Vynech klíčové slovo void v hlavičce funkce #include <iostream> int Soucet(int x, int y) std::cout << "Ve funkci Soucet(), prijato " << x << " a " << y << "\n"; return (x+y); using std::cout; using std::cin; cout << "Ve funkci main()!\n"; int a, b, c; cout << "Vlozte dve cisla: "; cin >> a; cin >> b; cout << "\nvolani funkce Soucet()\n"; c=soucet(a,b); cout << "\nzpet ve funkci main().\n"; cout << "c bylo nastaveno na " << c; cout << "\nkonec...\n\n"; Základy programování v jazyce C++ doprovodný text str. 8/52

Porovnej: cin>> vstup cout << výstup Pokud program obsahuje celé bloky stejných řádků, je velmi efektivní a přehledné tyto bloky zapsat do funkce, která nebude mít žádnou vrácenou hodnotu, tedy void. Úkol: Naprogramuj další 3 funkce, které dvě čísla na vstupu odečtou, vynásobí a vydělí. Ascii tabulka znaků Například: Alt+92 \ Místo desetinné čárky budeme používat desetinnou tečku!!! Ano 12.50 Ne 12,50 Základy programování v jazyce C++ doprovodný text str. 9/52

Českou diakritiku (znaky s háčky a čárkami) nebudeme používat u: názvů funkcí a proměnných v textových výstupech (výstupy jsou směrovány do okna konzoly neboli systému DOS). Českou diakritiku budeme používat u: komentářů Poznámky: Greerův 3. zákon: Počítačový program dělá jen to, co mu řeknete, nikdy však nedělá to, co byste chtěli, aby udělal. Základy programování v jazyce C++ doprovodný text str. 10/52

3. díl VYTVOŘENÍ ŠABLONY: // Název a autor programu #include <iostream> using namespace std; // cin >> " "; //cout << " \n"; char reakce; cin>>reakce; PROMĚNNÁ Proměnná úschovna pro data, které program potřebuje, místo pro dočasné uchování informace Proměnná se ukládá do místa v paměti, které má svoji adresu Proměnná má svoje jméno, program volá toto jméno, místo aby volal adresu v paměti. Proměnná může podle velikosti zabrat v paměti i více adres Každá přihrádka v paměti má velikost 1 B. Musíme kompilátoru říct, o jaký typ proměnné se jedná, aby podle toho připravil přihrádku v paměti. Jestliže typ proměnné má velikost 4 B, kompilátor připraví 4 přihrádky. Velikost objektu: sizeof příklad: sizeof(int) Velikost typu int: 4 bajty 2 DRUHY CELÝCH ČÍSEL: - se znaménkem signed (nastaveno implicitně) - bez znaménka unsigned (číslo bez znaménka je vždy kladné) Typ Velikost v Bytech Hodnoty Bool 1 True nebo false unsigned short int 2 0 až 65535 short int 2-32768 až 32767 unsigned long int 4 0 až 4294967295 long int 4-2147483648 až 2147483 647 int (16 bitů) 2-32768 až 32767 int (32 bitů) 4-2147483648 až 2147483 Základy programování v jazyce C++ doprovodný text str. 11/52

647 unsignet int (16 bitů) 2 0 až 65535 unsigned int (32 bitů) 4 0 až 4294967295 Char 1 256 znakových hodnot Float 4 1,2e-38 až 3,4e38 Double 8 2,2e-308 až 1,8e308 Čím větší číslo, tím více paměti. DEFINICE = DEKLARACE PROMĚNNÉ int mojemesto; typ název středník Jazyk C++ rozlišuje mezi velkými a malými písmeny! Dohodnutá konvence: moje_mesto nebo mojemesto V názvu proměnné nesmí být tzv. klíčová slova jako jsou: if, while, for, main VYTVOŘENÍ VÍCE PROMĚNNÝCH NAJEDNOU: - oddělujeme je čárkou unsigned int delka, sirka, obsah; Přiřazení (uložení) hodnoty do proměnné: unsigned short delka; delka = 10; Lze udělat najednou: unsigned short delka = 10; long delka = 10, sirka = 20; Vytvoř program, který vypočítá obsah a plochu obdélníka! PŘÍKAZ TYPEDEF = DEFINICE TYPU typedef unsigned short int USHORT; USHORT delka=10; //na místo: unsigned short delka; Základy programování v jazyce C++ doprovodný text str. 12/52

Vytvoř program, který vypočítá obvod a obsah kruhu. ZNAKY Počítač pracuje pouze s čísly, například písmeno a odpovídá číslu 97 (hodnota sady ASCII) Vyzkoušej: #include <iostream> for (unsigned char i = 32; i<128; i++) std::cout << i; KONSTANTY Konstanta na rozdíl od proměnné nemění svoji hodnotu během programu. 1. Literální (zadává se přímo v programu): int mojevyska=180; 2. Symbolická (je reprezentovaná názvem): Místo: celkem = cena * 20; Napíšu: celkem = cena * pocetkusu; //pocetkusu je symbolická konstanta DEFINICE SYMBOLICKÉ KONSTANTY DVĚMA ZPŮSOBY: 2a) pomocí #define - starý způsob #define pocetkusu 20 Preprocesor vloží do textu za slov pocetkusu hodnotu 20. Je to pouhé nahrazení textu! 2 b) pomocí const - zadám typ, zlepšená prevence chyb const unsigned short int pocetkusu = 20; VÝUČTOVÉ KONSTANTY Základy programování v jazyce C++ doprovodný text str. 13/52

- deklarace výčtem, např. typ barvargb bude nabývat hodnot cervena, zelena, modra (barvy monitoru) enum barvargb cervena, zelena, modra; Co se stalo? Založen nový typ + vytvoření symbolické konstanty cervena s hodnotou 0, zelena s hodnotou 1 a modra s hodnotou 2) Mohu nastavit: enum barvargb cervena=10, zelena=50, modra=70; Pokud zadáš enum barvargb cervena=10, zelena=50, modra; symbolická konstanta modra bude mít hodnotu 51 Úkol: Jak bys nastavil výučtovou konstantu reprezentující tiskové barvy CMYK? Vyzkoušej: #include <iostream> enum Dny Pondeli, Utery, Streda, Ctvrtek, Patek, Sobota, Nedele ; Dny dnes; dnes = Pondeli; if ( dnes == Sobota dnes == Nedele ) std::cout << "\nmiluji vikend \n"; else std::cout << "\nskola vola!.\n"; Vysvětlivky: if else podmínka nebo == porovnávací operátor Základy programování v jazyce C++ doprovodný text str. 14/52

Úkol: Vytvoř program, který odpoví na otázku, co děláš konkrétní den v týdnu (na vstupu bude den v týdnu, na výstupu konkrétní činnost). Zapiš ho na tento papír! Poznámky: Základy programování v jazyce C++ doprovodný text str. 15/52

4.díl PŘÍKAZY Jednoduchý - všechny končí středníkem Přiřazení: x = a + b; čteme: přiřaď a+b do x Složený = blok příkazů - začíná a končí složenými závorkami Příklad: Blok příkazů, který provede záměn hodnot dvou proměnných s pomocí třetí pomocné proměnné: pom = a; a = b; b = pom; // pom a // a b // b pom VÝRAZY = OPERAND - výraz vrací hodnotu x = a + b; vrací se hodnota x, která vznikla přiřazením výsledku součtu proměnných a, b Program: #include <iostream> using std::cout; using std::endl; int a=0, b=0, x=0, y=35; cout << "a:" << a << " b: " << b; cout << " x: " << x << " y: " << y << endl; a = 9; Poznámka b = 7; y = x = a+b; cout << "a:" << a << " b: " << b; cout << " x: " << x << " y: " << y << endl; // inicializace a deklarace proměnných // přiřazení hodnoty 9 proměnné a // přiřazení hodnoty 7 proměnné b Při tisku souboru s programem zaškrtni volbu Čísla řádků: Základy programování v jazyce C++ doprovodný text str. 16/52

OPERÁTOR = symbol určité akce nad operandem (nad výrazem) OPERÁTOR PŘIŘAZENÍ x = a + b; operand operátor přiřazení operand MATEMATICKÉ OPERÁTORY - sčítání (+), odečítání (-), násobení (*), dělení (/), dělení se zbytkem (%) Zbytek po celočíselném dělení 21 % 4 = 1 OPERÁTOR PLUS-ROVNÁ-SE cislo = cislo +2; cislo += 2; zvýší hodnotu proměnné cislo o 2 Inkrementace (++) = zvýšení hodnoty o 1 Dekrementace (--) = snížení hodnoty o 1 c = c + 1; nebo c+=1; nebo c++; Tzv. PREFIXOVÝ zápis: ++c Tzv. POSTFIXOVÝ zápis: c++ Úkol 4.1 Vytvoř jednoduchý program, který převede číslo 12 do dvojkové soustavy. Základy programování v jazyce C++ doprovodný text str. 17/52

Otestuj následující program: #include <iostream> using std::cout; int mujvek = 39; // inicializace dvou celočíselných proměnných int tvujvek = 39; cout << "Mam" << mujvek << " let.\n"; cout << "Mas" << tvujvek << " let.\n"; mujvek++; // postfixová inkrementace ++tvujvek; // prefixová inkrementace cout << "Uplynul jeden rok...\n"; cout << "Mam" << mujvek << " let.\n"; cout << "Mas" << tvujvek << " let.\n"; cout << "Uplynul dalsi rok...\n"; cout << "Mam" << mujvek++ << " let.\n"; cout << "Mas" << ++tvujvek << " let.\n"; cout << "Vytiskneme to znovu.\n"; cout << "Mam" << mujvek << " let.\n"; cout << "Mas" << tvujvek << " let.\n"; PRIORITA OPERÁTORŮ vnořené závorky vnější závorky mocnina, odmocnina násobení, dělení sčítání, odečítání TYP BOOL = pravdivost či nepravdivost výrazu (true či false) RELAČNÍ OPERÁTORY - porovnávání dvou hodnot (výrazů), vrací hodnotu True nebo False Název Operátor Příklad Výsledek Rovná se == 1 == 0; 1 == 1; F T Nerovná se!= 1!= 0; 0!=0 T F Větší než > 1 > 0; 1 > 1; T F Větší nebo rovno >= 1 >= 0; 1 >= 1; T T Menší než < 1 < 0; 1 < 1; F F Menší nebo rovno <= 1 <= 0; 1 <= 1; F T Základy programování v jazyce C++ doprovodný text str. 18/52

operátor přiřazení = relační operátor == PŘÍKAZ IF (podmínka; KDYŽ) podmínka - rozhodovací blok vývojového diagramu + podmínka není splněna podmínka je splněna PRO JEDEN PŘÍKAZ: if (výraz) příkaz; if (a > b) cout << cislo << a << je vetsi nez cislo << b; Pro lepší přehlednost budeme i jeden příkaz u podmínky if psát do složených závorek: if (a > b) cout << cislo << a << je vetsi nez cislo << b; Základy programování v jazyce C++ doprovodný text str. 19/52

PRO VÍCE PŘÍKAZŮ: if (výraz) příkaz1; příkaz2; příkaz3; bool vymena=true; if(vymena) pom = a; a = b; b = pom; Úkol: Zapiš následující program a vysvětli jeho chování : //demonstrace příkazu if #include <iostream> using std::cout; using std::cin; int skoresparta, skoreslavia; cout << "Vlozte skore Sparty: "; cin >> skoresparta; cout << "\nvlozte skore Slavie: "; cin >> skoreslavia; cout << "\n"; if (skoresparta > skoreslavia) cout << "Sparta do toho!\n"; if (skoresparta < skoreslavia) cout << "Slavia do toho!\n"; if (skoresparta == skoreslavia) cout << "Vyrovnane skore? To neni mozne!\n"; Základy programování v jazyce C++ doprovodný text str. 20/52

cout << "Zadejte skutecne skore Slavie: "; cin >> skoreslavia; if (skoresparta > skoreslavia) cout << "Vedel jsem to! Sparta do toho!"; if (skoreslavia > skoresparta) cout << "Vedel jsem to! Slavia do toho!"; if (skoresparta == skoreslavia) cout << "Aha, je to skutecne vyrovnane!"; cout << "\ndiky za informace.\n"; char cekej; cin >> cekej; PŘEHLED: if (výraz) příkaz; pokud je podmínka splněna, vykoná se příkaz na dalším řádku, pokud není splněna program jde na další řádek další příkaz+ Větvení ve dvou směrech if (výraz) pokud je podmínka splněna, vykoná se příkaz 1, pokud není splněna příkaz 1; vykoná se příkaz 2 else musí nastat jedna z možností další příkaz; příkaz 2; PŘÍKAZY IF MŮŽEME DO SEBE VNOŘOVAT A VYTVÁŘET TAK SLOŽITĚJŠÍ PROGRAMOVÉ KONSTRUKCE. Úkol 4.2 Vytvoř program pro slovní hodnocení, který vyhodnotí číslo na vstupu a pokud je vložena na vstup jednička, na výstupu napíše výborný, pokud je vložena dvojka, na výstupu napíše chvalitebný atd. Pokud je vloženo číslo jiné než 1 až 5, napíše chybovou zprávu. Nakresli rozhodovací bloky vývojového diagramu. Základy programování v jazyce C++ doprovodný text str. 21/52

LOGICKÉ OPERÁTORY AND (zároveň) && výraz1 && výraz2 OR (nebo) výraz1 výraz2 NOT (negace;opak)!!výraz if (( x == 5) && (y == 5)) if (( x == 5) (y == 5)) if (!( x == 5)) //AND; pokud není splněna 1. podmínka, kompilátor jde dál //OR //NOT Úkol 4.3 Vytvoř program, který bude řešit pravdivostní hodnotu operace konjunkce (výroková logika). Připomínám, že konjunkce je pravdivá, jsou-li oba výroky pravdivé. Pokud se ti to podaří, neboj se a pusť se do naprogramování všech pěti základních logických operací. Tou pátou je negace. Good luck Poznámky: Základy programování v jazyce C++ doprovodný text str. 22/52

5. díl Funkce = podprogram, který umí zpracovat data a vrátit hodnotu. - vestavěné - uživatelsky definované int mojefunkce(); vrací celočíselnou hodnotu char mojefunkce(); vrací znak int mojefunkce (int celociselnahodnota, float zlomek) Deklarace funkce: - prototyp funkce se napíše do souboru a pak se tento soubor s pomocí direktivy #include zahrne do programu - prototyp funkce se zapíše do souboru, ve kterém se funkce používá - funkce se definuje pře tím, než ji jiná funkce bude volat. long Plocha(int delka, int sirka); Obor platnosti proměnných - Lokální proměnné mají platnost jen uvnitř bloku ohraničeného složenými závorkami, uvnitř funkce. Když funkce vrátí řízení, přestanou být lokální proměnné dostupné. Lokálními proměnnými jsou i parametry předávané funkcí. - Globální proměnné platí v celém programu Prostuduj pečlivě následující program #include <iostream> float Prevod(float); using namespace std; float TeplotaFer; float TeplotaCel; cout << "Vlozte prosim teplotu v jednotkach Fahrenheita: "; cin >> TeplotaFer; TeplotaCel = Prevod(TeplotaFer); cout << "\na zde je teplota v jednotkach Celsia: "; cout << TeplotaCel << endl; Základy programování v jazyce C++ doprovodný text str. 23/52

float Prevod(float TeplotaFer) float TeplotaCel; TeplotaCel = ((TeplotaFer - 32) * 5) / 9; return TeplotaCel; Následující program demonstruje platnost lokálních proměnných v bloku #include <iostream> void mojefunkce(); int x = 5; std::cout << "\nv main je hodnota x: " << x; mojefunkce(); std::cout << "\nzpatky v main, hodnota x je: " << x; void mojefunkce() int x = 8; std::cout << "\nuvnitr mojefunkce, lokalni promenna x: " << x << std::endl; std::cout << "\nv bloku funkce mojefunkce, hodnota x je: " << x; int x = 9; std::cout << "\nzcela lokalni promenna x: " << x; std::cout << "\nmimo blok, uvnitr mojefunkce, x: " << x << std::endl; Parametry jako lokální proměnné demonstruje následující program: #include <iostream> void zamena(int x, int y); int x = 5, y = 10; std::cout << "Funkce main. Pred zamenou, x: " << x << " y: " << y << "\n"; zamena(x,y); Základy programování v jazyce C++ doprovodný text str. 24/52

std::cout << "Funkce main. Po zamene, x: " << x << " y: " << y << "\n"; void zamena (int x, int y) int pom; std::cout << "Funkce zamena. Pred zamenou, x: " << x << " y: " << y << "\n"; pom = x; x = y; y = pom; std::cout << "Funkce zamena. Po zamene, x: " << x << " y: " << y << "\n"; Globální proměnné: #include <iostream> void mojefunkce(); // prototyp int x = 5, y = 7; // globální proměnné using std::cout; cout << "x ve funkci main: " << x << "\n"; cout << "y ve funkci main: " << y << "\n\n"; mojefunkce(); cout << "Navrat z mojefunkce!\n\n"; cout << "x ve funkci main: " << x << "\n"; cout << "y ve funkci main: " << y << "\n"; void mojefunkce() using std::cout; int y = 10; cout << "x ve funkci mojefunkce: " << x << "\n"; cout << "y ve funkci mojefunkce: " << y << "\n\n"; Poznámka: V případě více funkcí v programu může být deklarování globálních proměnných nevhodné. Základy programování v jazyce C++ doprovodný text str. 25/52

Příklad k opakování (funkce bez návratové hodnoty): Vytvoř program s několika příkazy cout, mezi tyto řádky vložte funkci, která vynechá 5 řádků. Ladění programu K ladění programu si vybereme předchozí program, budeme sledovat hodnoty proměnných x a y. Postup: 1. Zkompiluji zdrojový kód Ctrl+F9 2. Umístím breakpointy na řádky ve zdrojovém kódu pomocí Ctrl+F5 3. Spustím ladění F8 (Debug Ladit) 4. Debug - Sledovat proměnné Ctrl+W v levém okně sleduji hodnoty proměnných 5. Debug - Ukončit provádění Ctrl+Alt+F2 Poznámky: Základy programování v jazyce C++ doprovodný text str. 26/52

6. díl Smyčka while - opakované provádění příkazů v bloku dokud je počáteční podmínka pravdivá (je splněna) while (podmínka) while (podmínka) příkaz; příkazy; // Smyčka s while #include <iostream> int citac = 0; // inicializace podmínky while(citac < 5) // test, zda je podmínka stále pravdivá citac++; // tělo smyčky std::cout << "citac:" << citac << "\n"; std::cout << "Hotovo, citac: " << citac << ".\n"; char reakce; cin>>reakce; podmínka + příkaz - Příkaz continue; skok zpět na začátek smyčky Příkaz break; předčasné vyskočení ze smyčky a pokračování za while (podmínka) if (podmínka 2) break; //příkazy; Základy programování v jazyce C++ doprovodný text str. 27/52

Smyčka while (true) while (true) if (podmínka 2) break; //příkazy; // Demonstruje nekonečnou smyčku "while true" #include <iostream> int citac = 0; while (true) citac ++; if (citac > 10) break; std::cout << "Citac: " << citac << "\n"; char reakce; cin>>reakce; Smyčka do while Tělo smyčky se provede předtím, než se otestuje její podmínka. Tím je zajištěno, že se tělo smyčky provede alespoň jedenkrát. příkaz podmínka + - do příkaz; while (podmínka); Základy programování v jazyce C++ doprovodný text str. 28/52

//Program demonstruje smyčku do while #include <iostream> using namespace std; int citac; cout << "Kolik pozdravu? "; cin >> citac; do cout << "Ahoj\n"; citac--; while (citac > 0); cout << "Hodnota citace: " << citac << endl; char reakce; cin>>reakce; Smyčka for for ( inicializace; test+ akce ) příkaz; // Smyčka for #include <iostream> int citac; for (citac = 0; citac < 5; citac++) std::cout << "Smycka! "; std::cout << "\ncitac: " << citac << ".\n"; char reakce; cin>>reakce; Základy programování v jazyce C++ doprovodný text str. 29/52

Vytvoř program na výpočet faktoriálu. n! = n (n-1)(n-2) 3.2.1 Například: 5! = 5.4.3.2.1 = 120 Příkaz switch switch (výraz) case prvnihodnota: case druhahodnota: case ntahodnota: default: prikaz; prikaz; prikaz; prikaz; Základy programování v jazyce C++ doprovodný text str. 30/52

// Ukázka příkazu switch #include <iostream> using namespace std; unsigned short int cislo; cout << "Vlozte cislo mezi 1 a 5: "; cin >> cislo; switch (cislo) case 0: cout << "Vlozil jsi cislo mensi nez 1!"; break; case 5: cout << "nedostatecny\n"; break; case 4: cout << "dostatecny\n"; break; case 3: cout << "dobry\n"; break; case 2: cout << "chvalitebny\n"; break; case 1: cout << "vyborny\n"; default: break; cout << "Vlozil jsi cislo vetsi nez 5!\n"; break; cout << "\n\n"; char reakce; cin>>reakce; ------------------------------------------------------------------------------------------------------------------------------ Poznámky: Základy programování v jazyce C++ doprovodný text str. 31/52

7. díl Základy programování v jazyce C++ doprovodný text str. 32/52

Na diagramu je vidět struktura zdrojového kódu v jazyku C++. Jak už si několikrát řekli a v programech odladili, nejdříve na prvním řádku programu napiš název, programu, svoje jméno, datum vytvoření a verzi. Potom zadej příkazy na vložení externích souborů, například knihovny matematických funkcí. Dále definuj externí proměnné, které nezmění svoje hodnoty během celého programu. Potom následuje definice uživatelských funkcí, které definuju ještě před hlavní částí programu. Dále vždy následuje hlavní část programu a uvnitř zadávej jednoduché příkazy, volání uživatelsky definovaných funkcí atd. Blok příkazů musí být vždy vymezen složenými závorkami. Na následující stránce rozebereme program na výpočet elektrotechnických veličin podle Ohmova zákona. Obsahuje větvený příkaz Switch a jednotlivé vzorce pro výpočet jsou volány jako uživatelsky definované funkce. Základy programování v jazyce C++ doprovodný text str. 33/52

// Ohmův zákon, miskota, 14.11.2009, v.3 - s užitím funkcí a příkazu SWITCH #include <iostream> //umožní používat vstupní a výstupní příkazy cin a cout //tady definuj uživatelské funkce: double napeti (double x, double y) return(x* y); double odpor (double x, double y) return(x/ y); double proud (double x, double y) return(x/ y); definice funkce obsah funkce using namespace std; // nemusím psát před příkazy cin a cout příkaz std:: //sem napiš hlavní část programu: cout << "Program OHMUV ZAKON\n"; cout << "U = R. I\n"; cout << "R = U / I\n"; cout << "I = U / R\n"; double u, r, i; int volba; //nabídkové menu cout << "\ntvoje volba: 1-vypocita napeti, 2-vypocita odpor, 3-vypocita proud\n"; cin >> volba; switch (volba) proměnné hlavní část programu výpis na obrazovku definice proměnných na vstupu proměnná volba větvení programu podle hodnoty case 1: proměnná má hodnotu 1 cout << "Zadej odpor a proud\n"; cin >> r >> i; u = napeti (r, i); cout << "Napeti na obvodu je " << u << " voltu\n"; break; case 2: proměnná má hodnotu 2 cout << "Zadej napeti a proud\n"; cin >> u >> i; r = odpor (u, i); cout << "Odpor v obvodu ma " << r << " ohmu\n"; break; case 3: proměnná má hodnotu 3 Základy programování v jazyce C++ doprovodný text str. 34/52

cout << "Zadej napeti a odpor\n"; cin >> u >> r; i = proud (u, r); cout << "Proud v obvodu je " << i << " amper\n"; break; default: cout << "Vlozil jsi spatne cislo!\n"; break; cout << "\n\n"; char reakce; cin >> reakce; 7.1 Vytvoř program na aplikaci vzorců v = s / t, s = v. t, t = s / v a dále program na procenta, který vypočítá základ, procentuelní část nebo počet procent (z, č, p). Základy programování v jazyce C++ doprovodný text str. 35/52

Připomenutí: Následující schémata ukazují rozdíl v použití příkazů if a switch. Pokud program má na základě testu nějaké proměnné pokračovat dvěma cestami, použij příkaz if. Pokud má dále pokračovat více jak dvěma cestami, použij příkaz switch. Tady použij příkaz if ( podmínka) Blok příkazů Tady použij příkaz switch( proměnná) Case 1: příkazy break; Case 2: příkazy break; ------------------------------------------------------------------------------------------------------------------------------ Poznámky: Základy programování v jazyce C++ doprovodný text str. 36/52

8. díl Pole a řetězce Pole je určitá kolekce míst v úložišti dat, z nichž každé obsahuje stejný typ dat. Pole se deklaruje zadáním typu, za nímž následuje název pole a index (subskript). Index je počet prvků pole uzavřený v hranatých závorkách. int PoleCisel[10]; typ - název - počet prvků Prvky pole se počítají od nuly: první prvek PoleCisel [0]; druhý prvek PoleCisel [1];... desátý prvek PoleCisel [9]; Příklad na vložení a posléze zobrazení deseti prvků pole s názvem mojepole: //Výpis 13.1 - Pole #include <iostream> int mojepole[10]; int i; for ( i=0; i<10; i++) // 0-9 std::cout << "Hodnota mojepole[" << i << "]:"; std::cin >> mojepole[i]; for (i = 0; i<10; i++) std::cout << i << ":" << mojepole[i] << "\n"; Inicializace polí //na vstupu 10 prvků pole //výstup na obrazovku int PoleCelych cisel[5] = 10, 20, 30, 40, 50; nelze deklarovat víc prvků než je velikost pole (méně lze) int PoleCelych cisel[ ] = 10, 20, 30, 40, 50; velikost pole lze vynechat Nelze používat stejný název pro pole a pro proměnnou! Základy programování v jazyce C++ doprovodný text str. 37/52

Vícerozměrná pole Dvojrozměrné pole má dva indexy, trojrozměrné pole má tři indexy atd. Příkladem dvojrozměrného pole šachovnice nebo adresy buněk v Excelu. U šachovnice první rozměr představuje osm řádků a druhý rozměr představuje osm sloupců. int Sachovnice [8][8]; je mnohem reálnější než jednorozměrné pole int Sachovnice [64]; Bílý kůň se nachází v 5. řádku a ve 4. sloupci. Tato pozice odpovídá prvku pole: Sachovnice [4][3]; Příklad: Načti do proměnné typu pole 3 teploty měřených během dne. Zjisti maximální teplotu a kolikátá byla v pořadí. Hlavní část programu: int poleteplot[3]; for (int i=0; i<3; i++) cin >> poleteplot[i]; for (int i=0; i<3; i++) cout << poleteplot[i]; //maximum int poradi = 0; int max = poleteplot[0]; Základy programování v jazyce C++ doprovodný text str. 38/52

for (int i=1; i<3; i++) if (poleteplot[i]>max) max = poleteplot[i]; poradi = i; cout << "Maximum je " << max; cout << "byl to prvek pole číslo " << poradi + 1; char reakce; cin >> reakce; Úkol: Sestav program, který zjistí nejmenší a průměrnou teplotu ze zadaných hodnot. Pole znaků zakončené hodnotou null. Toto pole je považováno za řetězec stylu jazyka C. cout << Ahoj, světe. ; deklarovat a inicializovat řetězec C můžeme stejným způsobem jako kterékoli jiné pole. char Pozdrav[ ] = A, h, o, j,,,, s, v, ě, t, e,., \0 ; Proměnná Pozdrav je deklarována jako pole znaků, kterými je také inicializována. Poslední znak \0 je znak null ukončovací řetězec. Lze psát: char Pozdrav [ ] = Ahoj, světe. ; Příklad: Neinicializované znakové pole: char buffer[80]; //deklarovaný buffer pro 80 znaků (79 znaků + null) std::cout << "Zadejte retezec: "; std::cin >> buffer; std::cout << "Zde mame buffer: " << buffer << std::endl; Základy programování v jazyce C++ doprovodný text str. 39/52

Použití speciální metody nazvané get() pro objekt cin Metoda cin.get() přebírá tři parametry: 1. Naplňovaný buffer 2. Maximální počet přebíraných znaků 3. Oddělovač ukončovací daný řetězec char buffer[80]; cout << "Zadejte retezec: "; cin.get(buffer, 79); // převzít až 79 znaků nebo po nový řádek cout << "Zde mame buffer: " << buffer << endl; Program pro kopírování řetězců, metoda strcpy() #include <iostream> //umožní používat vstupní a výstupní příkazy cin a cout #include <string.h> //obsahuje prototyp funkce strcpy() using namespace std; // nemusím psát před příkazy cin a cout příkaz std:: //sem napiš hlavní část programu: char retezec1[10]; char retezec2[10]; cin.get(retezec1,10); strcpy(retezec2,retezec1); //zkopíruje retezec1 do retezce2 cout << retezec1 << "\n"; cout << retezec2 << "\n"; char reakce; cin >> reakce; Poznámky: Základy programování v jazyce C++ doprovodný text str. 40/52

9. díl Algoritmus & Vývojový diagram Algoritmus je přesný postup, který vede k vyřešení určitého výsledku. Vysvětlili jsme si pojem algoritmus a přidáme ještě jeden pojem a to deterministický. Znamená to, že pokud programu dáme určitá data, tak nám vrátí výsledek, a pokud mu tatáž data zadáme znovu, výsledek bude totožný s předchozím. Algoritmus je přesný návod či postup, kterým lze vyřešit daný typ úlohy. Pojem algoritmu se nejčastěji objevuje při programování, kdy se jím myslí teoretický princip řešení problému (oproti přesnému zápisu v konkrétním programovacím jazyce). Obecně se ale algoritmus může objevit v jakémkoli jiném vědeckém odvětví. Jako jistý druh algoritmu se může chápat i např. kuchyňský recept. V užším smyslu se slovem algoritmus rozumí pouze takové postupy, které splňují některé silnější požadavky: Vlastnosti algoritmů Konečnost (finitnost) Každý algoritmus musí skončit v konečném počtu kroků. Tento počet kroků může být libovolně velký (podle rozsahu a hodnot vstupních údajů), ale pro každý jednotlivý vstup musí být konečný. Postupy, které tuto podmínku nesplňují, se mohou nazývat výpočetní metody. Speciálním příkladem nekonečné výpočetní metody je reaktivní proces, který průběžně reaguje s okolním prostředím. Někteří autoři však mezi algoritmy zahrnují i takovéto postupy. Obecnost (hromadnost, masovost, univerzálnost) Algoritmus neřeší jeden konkrétní problém (např. jak spočítat 3 7 ), ale obecnou třídu obdobných problémů (např. jak spočítat součin dvou celých čísel ), má širokou množinu možných vstupů. Determinovanost Každý krok algoritmu musí být jednoznačně a přesně definován; v každé situaci musí být naprosto zřejmé, co a jak se má provést, jak má provádění algoritmu pokračovat, takže pro stejné vstupy dostaneme pokaždé stejné výsledky. Protože běžný jazyk obvykle neposkytuje naprostou přesnost a jednoznačnost vyjadřování, byly pro zápis algoritmů navrženy programovací jazyky, ve kterých má každý příkaz jasně definovaný význam. Vyjádření výpočetní metody v programovacím jazyce se nazývá program. Některé algoritmy ale determinované nejsou, pravděpodobnostní algoritmy v sobě mají zahrnutu náhodu. Výstup (resultativnost) Algoritmus má alespoň jeden výstup, veličinu, která je v požadovaném vztahu k zadaným vstupům, a tím tvoří odpověď na problém, který algoritmus řeší (algoritmus vede od zpracování hodnot k výstupu) Elementárnost Algoritmus se skládá z konečného počtu jednoduchých (elementárních) kroků. V praxi jsou proto předmětem zájmu hlavně takové algoritmy, které jsou v nějakém smyslu kvalitní. Takové algoritmy splňují různá kritéria, měřená např. počtem kroků potřebných pro běh algoritmu, jednoduchost, efektivitu či eleganci. Problematikou efektivity algoritmů, tzn. metodami, jak z několika známých algoritmů řešících konkrétní problém vybrat ten nejlepší, se zabývají odvětví informatiky nazývané algoritmická analýza a teorie složitosti. Základy programování v jazyce C++ doprovodný text str. 41/52

Vývojový diagram je tedy grafické znázornění algoritmu. Vývojové diagramy se skládají z grafických značek. Značky jsou různé a různě se kombinují, tím se simulují různé situace a různé příkazy, do těchto značek se pak vypisují upřesňující údaje. Nyní se podíváme na to, jak vypadají jednotlivé části vývojového diagramu. Konec a začátek algoritmu Běžný příkaz c = a + b; Podmíněný výraz if (podmínka) blok příkazů Cyklus s určeným počtem opakování for (inicializace, podmínka, přírůstek) blok příkazů; Cyklus s podmínkou na konci do blok příkazů; while (podmínka); Cyklus s podmínkou na začátku while (podmínka) blok příkazů; Ruční vstup cin >> proměnná; Zobrazení výstupu cout << text << proměnná; Základy programování v jazyce C++ doprovodný text str. 42/52

Zpracování souboru Uložení dat do souboru Podprogram Spojovací značka Spojovací čára Odkazy: http://www.ikvalita.cz/download/kap2.pdf http://www.emag.cz/jak-jednoduse-a-zdarma-nakreslit-vyvojove-diagramy-online/ http://programujte.com/?akce=clanek&cl=2005080105-vyvojove-diagramy-1-dil http://www.algoritmy.net/ http://www.cmsps.cz/~marlib/diagramy/diagramy.html Základy programování v jazyce C++ doprovodný text str. 43/52

Tip DiaCze 1.0 Pomocí této aplikace můžete velice jednoduše kreslit diagramy a modelovat chování složitých systémů a to od komplexního vnějšího pohledu až po detailní popis konkrétních součástí obecně libovolného systému. Aplikace DiaCze Vám umožní kreslit UML, EML diagramy ER, ERD, stavové digramy, topologie sítí, Cisco páteřní sítě, Mapy oblastí, vývojové diagramy - minispecifikace a pochopitelně business modelování stavů, chování a rolí ve velkých firmách a nadnárodních korporacích. Ačkoliv DiaCze v mnoha ohledech předčí schopnosti konkurenčního produktu Microsoft Visio, je dodávána zcela zdarma jakožto freeware pod záštitou GNU GPL licence. Licence: Vim's license Download: http://www.slunecnice.cz/sw/diacze/ Vývojový diagram pro výpočet napětí v elektrickém obvodu podle Ohmova zákona vytvořený v aplikaci DiaCze 1.0 Základy programování v jazyce C++ doprovodný text str. 44/52

Nyní zapíšeme vývojový diagram pro zjištění nejvyšší teploty z úlohy předchozího 8. dílu: Hlavní část programu: int poleteplot[3]; for (int i=0; i<3; i++) cin >> poleteplot[i]; for (int i=0; i<3; i++) cout << poleteplot[i]; //maximum int poradi = 0; int max = poleteplot[0]; for (int i=1; i<3; i++) if (poleteplot[i]>max) max = poleteplot[i]; poradi = i; cout << "Maximum je " << max; cout << "byl to prvek pole číslo " << poradi + 1; Úkol 9.1: S pomocí aplikace DiaCze 1.0 sestav vývojový diagram na kompletní řešení Ohmova zákona ze 7. dílu. ------------------------------------------------------------------------------------------------------------------------------ Poznámky: Základy programování v jazyce C++ doprovodný text str. 45/52

10. díl Ukazatele Schopnost používat ukazatele a manipulovat s pamětí na velmi nízké úrovni činí z jazyka C++ nejlepší programovací jazyk pro vestavěné aplikace a aplikace pracující v reálném čase. Ukazatel je proměnná, která uchovává paměťovou adresu. Paměť počítače je rozdělena do sekvenčně číslovaných paměťových buněk. Každá proměnná je umístěna na jedinečném místě v paměti, která se označuje její adresou. Operátor adresy & vrací adresu objektu v paměti: using namespace std; unsigned short promennashort=5; unsigned long promennalong=65535; long zpromenna = -65535; cout << "promenna typu Short:\t" << promennashort; cout << "\tadresa promenne typu Short:\t"; cout << &promennashort << "\n"; cout << "promenna typu Long:\t" << promennalong; cout << "\tadresa promenne typu Long:\t"; cout << &promennalong << "\n"; cout << "promenna se znamenkem:\t" << zpromenna; cout << "\tadresa promenne se znamenkem:\t"; cout << &zpromenna << "\n"; Popis programu: Postupně se inicializují proměnné: proměnná typu unsigned short, dále proměnná typu unsigned long a nakonec proměnná typu long. &promennashort &promennalong &zpromenna Základy programování v jazyce C++ doprovodný text str. 46/52

Potom se vytisknou jejich hodnoty a díky operátoru & i jejich adresy v paměti počítače. Adresy jsou specifické a liší se podle počítače, i při každém spuštění programu. deklarace typu nese informaci, kolik paměti má kompilátor proměnné vymezit. Například proměnná typu má obvykle 4 bajty long int, což znamená, že proměnná má adresu souvislého úseku 4 bajtů paměti. Každá proměnná má svoji adresu. Adresu proměnné nemusíme znát, ale můžeme ji uložit do ukazatele. Proměnná > Adresa(proměnné) > Ukazatel (proměnná) Deklarace proměnné ukrok do které se uloží její adresa: int *ukrok = 0; int * pyear = 0; uk ukazatel p pointer Vznikne proměnná ukrok jako ukazatel na typ int. Proměnná ukrok bude uchovávat adresu celého čísla. Dbáme na to, aby ukazatel měl vždy inicializovanou nějakou hodnotu, pokud ji neznáme, přiřadíme hodnotu nula (nulový ukazatel). Aby ukazatel obsahoval adresu, musíme mu nějakou přiřadit: unsigned short int jakstary = 16; unsigned short int * ukvek = 0; ukvek = &jakstary; // vytvoření proměnné // vytvoření ukazatele // vložení adresy proměnné jakstary do proměnné ukvek Stručněji můžeme napsat: unsigned short int jakstary = 16; // vytvoření proměnné unsigned short int * ukvek = &jakstary; // vytvoření ukazatele na proměnnou jakstary Prostřednictvím ukazatele ukvek lze nepřímo získat hodnotu proměnné jakstary. Běžná proměnná v. proměnná Ukazatel Běžná proměnná pro kompilátor znamená, kolik paměti je potřeba k uchování hodnoty. Typ pro kompilátor znamená, kolik paměti spotřebuje objekt na adrese, která je v ukazateli uložena. Operátor nepřímého přístupu * operátor zrušení odkazu; získání odkazu ukazatele; získání hodnoty uložené na adrese, jejíž hodnota je v ukazateli. Základy programování v jazyce C++ doprovodný text str. 47/52

Ukazatel poskytuje nepřímý přístup k hodnotě proměnné, jejíž adresu uchovává. Chceme-li prostřednictvím ukazatele ukvek přiřadit hodnotu proměnné jakstary, napíšeme: unsigned short int tvujvek; tvujvek = *ukvek; //čteme: hodnota uložená na adrese Vezmi hodnotu uloženou na adrese dané hodnotou ukazatele ukvek a přiřaď ji do tvujvek. Ukazatel má stejnou velikost, obvykle 5 bajty na počítači s 32 bitovým procesorem a 8 bajtů na počítači s 64 bitovým procesorem. ------------------------------------------------------------------------------------------------------------------------------ Poznámky: Základy programování v jazyce C++ doprovodný text str. 48/52

11. díl Ukazatele, adresy a proměnné Jakmile je ukazateli přiřazena adresa proměnné, je možné jej použít k získání přístupu k datům v této proměnné. // Používání ukazatelů #include <iostream> typedef unsigned short int USHORT; using std::cout; using std::cin; USHORT mujvek; // proměnná USHORT *ukvek; // ukazatel mujvek = 5; cout << "mujvek: " << mujvek << "\n"; ukvek = &mujvek; // přiřazení adresy proměnné mujvek do ukvek cout << "*ukvek: " << *ukvek << "\n\n"; //zrušení odkazu ukazatele ukvek a jeho tisk cout << "Nastaveni*ukVek na 7...\n"; *ukvek = 7; // nastavení mujvek na 7 //proměnné na adrese uložené v ukazateli ukvek se //přiřadí hodnota 7 cout << "*ukvek: " << *ukvek << "\n"; cout << "mujvek: " << mujvek << "\n\n"; cout << "Nastaveni mujvek na 9...\n"; mujvek = 9; cout << "mujvek: " << mujvek << "\n"; cout << "*ukvek: " << *ukvek << "\n"; char vstup; cin >> vstup; Popis programu: Deklarace dvou proměnných: mujvek typu unsigned short a ukazatel ukvek na proměnnou typu unsigned short. Ukazatele umožňují manipulaci s adresami, aniž bychom znali jejich skutečné hodnoty. Základy programování v jazyce C++ doprovodný text str. 49/52

Když přiřadíme ukazateli adresu proměnné, bude mít ukazatel skutečně adresu této proměnné jako svou hodnotu. Tento fakt demonstruje další příklad: // Hodnoty ukazatelů #include <iostream> using std::cout; unsigned short int mujvek = 5, tvujvek = 10; // ukazatel unsigned short int * ukvek = &mujvek; cout << "mujvek:\t\t" << mujvek << "\t\ttvujvek:\t" << tvujvek << "\n"; cout << "&mujvek:\t" << &mujvek << "\t&tvujvek:\t" << &tvujvek << "\n"; cout << "ukvek:\t\t" << ukvek << "\n"; cout << "*ukvek:\t\t" << *ukvek << "\n"; cout << "\nprenastaveni ukvek = &tvujvek...\n\n"; ukvek = &tvujvek; // přenastavení ukazatele cout << "mujvek:\t\t" << mujvek << "\t\ttvujvek:\t" << tvujvek << "\n"; cout << "&mujvek:\t" << &mujvek << "\t&tvujvek:\t" << &tvujvek << "\n"; cout << "ukvek:\t\t" << ukvek << "\n"; cout << "*ukvek:\t\t" << *ukvek << "\n"; cout << "\n&ukvek:\t\t" << &ukvek << "\n"; char vstup; cin >> vstup; Rozdělení paměti Základy programování v jazyce C++ doprovodný text str. 50/52

Lokální proměnné jsou spolu s parametry funkcí v zásobníku. Kód je v prostoru kódu, globální proměnné jsou v globálním oboru názvů. Interní funkce správy běhu programu, sledování vrcholu zásobníku a ukazatele na aktuální instrukci jsou v registrech. Veškerá volná zbývající paměť je označována jako halda nebo volné úložiště. Halda ani zásobník se nedají nijak označit, proto musíme požádat o adresu přihrádky, která se vyhradí, a pak tuto adresu uložíme do ukazatele. Ukazatel můžeme vtipně přirovnat k tlačítku na telefonu, do kterého uložíme konkrétní telefonní číslo. Číslo vytočím stisknutím tlačítka a přitom si ho nemusím pamatovat. Na rozdíl od místních proměnných uložených v zásobníku, které jsou odstraněny při návratu z funkce, se volné úložiště neuvolní, dokud program neskončí. Pokud nepotřebujeme vyhrazenou paměť, uvolníme ji. Ve srovnání s globálními proměnnými je přístup k haldě lepší, protože přístup k datům mají pouze funkce, které mají přístup k ukazateli. Tím vzniká striktně kontrolované rozhraní pro přístup k datům. Klíčové slovo new vyhrazení paměti ve volné oblasti new unsigned short int ve volné oblasti se vymezí dva bajty new long čtyři bajty návratovou hodnotou operátoru new je paměťová adresa, kterou je nutné přiřadit ukazateli. Vytvoření objektu typu unsigned short: unsigned short int * ukukazatel; ukukazatel = new unsigned short int; Základy programování v jazyce C++ doprovodný text str. 51/52

nebo najednou: unsigned short int * ukukazatel = new unsigned short int; Do oblasti paměti ukazatele můžeme přiřadit hodnotu: *ukukazatel = 72; Lze říci: Přiřaď hodnotu 72 do části ve volném úložišti, na kterou ukazuje ukukazatel. Po skončení práce s jistou částí paměti zavoláme na ukazatel operátor delete. delete ukukazatel; Lze říci: Vrať do volného úložiště tu část paměti, na kterou ukazuje tento ukazatel. Pokud bych opakovaně použil delete na stejný ukazatel, zhroutí se program! Proto je dobré po příkazu delete ukazatel vynulovat: Zvire *unes = new Zvire; delete ukpes; //uvolní paměť ukpes = 0; //nastaví ukazatel na nulu delete ukpes; //neškodné Příklad: Přidělení místa ve volné paměti proměnné, použité této proměnné a uvolnění jí používané paměti. // Alokace a smazání ukazatele #include <iostream> using std::cout; using std::cin; int lokalnipromenna = 5; int * uklokalni = &lokalnipromenna; int * ukhromada = new int; *ukhromada = 7; cout << "lokalnipromenna: " << lokalnipromenna << "\n"; cout << "*uklokalni: " << *uklokalni << "\n"; cout << "*ukhromada: " << *ukhromada << "\n"; delete ukhromada; ukhromada = new int; *ukhromada = 9; cout << "*ukhromada: " << *ukhromada << "\n"; delete ukhromada; char vstup; cin >> vstup; Základy programování v jazyce C++ doprovodný text str. 52/52