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. 2. 3. -

-

Procedurální (Sada přesně stanovených instrukcí, které se provádějí jedna po druhé) Strukturované (Dělení větších úkolů na menší části; od složitějšího k jednoduššímu) 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/


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 int main() { std::cout << "Nazdar lidi!\n"; return 0; } 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


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. 2. 3. 4. 5. 6. 7.

Zvolte: Soubor – Nový – Projekt Zvolte: Console Application Zadejte název projektu Vyberte umístění projektu na disku a potvrďte Do otevřeného souboru vložte zdrojový kód nebo ho zkopírujte z jiného souboru Zvolte: Spustit – Zkompilovat a spustit Zadejte název spustitelného programu, který bude vytvořen.

…program bude přeložen a spuštěn…

Poznámky:


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 direktivu # tzv. preprocesor najde příkazový řádek s křížkem ještě před spuštěním kompilátoru int main() 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) { std::cout << "Nazdar lidi!\n"; return 0;

všechny funkce začínají a končí závorkou { a } 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 int main() { 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"; return 0; } Základy programování v jazyce C++

doprovodný text

str. 5/52

Příkazu cout musí předcházet příkaz #include 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é /* … */


doprovodný text

str. 6/52

#include int main() { 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 */ return 0; } 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. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ FUNKCE 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.


doprovodný text

str. 7/52

Příklad funkce: #include // 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 int main() { std::cout << "Ve funkci main\n"; IlustracniFunkce(); std::cout << "Zpet ve funkci main\n"; return 0; }

Funkce vrací buď skutečnou hodnotu, nebo prázdnou hodnotu typu void. Vyzkoušej: 1. Voláme funkci, která není definována. 2. Vynech klíčové slovo void v hlavičce funkce Opiš programový kód: #include int Soucet(int x, int y) { std::cout << "Ve funkci Soucet(), prijato " << x << " a " << y << "\n"; return (x+y); } int main() { 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"; return 0; }


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

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.


doprovodný text

str. 10/52

3. díl VYTVOŘENÍ ŠABLONY: // Název a autor programu #include int main() { using namespace std; // cin >> "…"; //cout << "…\n"; char reakce; cin>>reakce; return 0; }

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

Bool unsigned short int short int unsigned long int long int

1 2 2 4 4

int (16 bitů) int (32 bitů)

2 4


Hodnoty True nebo false 0 až 65 535 -32 768 až 32 767 0 až 4 294 967 295 -2 147 483 648 až 2 147 483 647 -32 768 až 32 767 -2 147 483 648 až 2 147 483

doprovodný text

str. 11/52

unsignet int (16 bitů) unsigned int (32 bitů) Char Float Double

647 0 až 65 535 0 až 4 294 967 295 256 znakových hodnot 1,2e-38 až 3,4e38 2,2e-308 až 1,8e308

2 4 1 4 8

Čí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;


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 int main() { for (unsigned char i = 32; i<128; i++) std::cout << i; return 0; }

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


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 int main() { 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

return 0;

== porovnávací operátor

}


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:


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 int main() { using std::cout; using std::endl; int a=0, b=0, x=0, y=35; // inicializace a deklarace proměnných cout << "a: " << a << " b: " << b; cout << " x: " << x << " y: " << y << endl; a = 9; // přiřazení hodnoty 9 proměnné a b = 7; // přiřazení hodnoty 7 proměnné b y = x = a+b; cout << "a: " << a << " b: " << b; cout << " x: " << x << " y: " << y << endl; return 0; } Poznámka Při tisku souboru s programem zaškrtni volbu Čísla řádků:


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

Úkol 4.1

Tzv. POSTFIXOVÝ zápis: c++

Vytvoř jednoduchý program, který převede číslo 12 do dvojkové soustavy.


doprovodný text

str. 17/52

Otestuj následující program:

#include int main() { 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"; return 0; }

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 Rovná se Nerovná se Větší než Větší nebo rovno Menší než Menší nebo rovno

Operátor == != > >= < <=


Příklad 1 == 0; 1 == 1; 1 != 0; 0 !=0 1 > 0; 1 > 1; 1 >= 0; 1 >= 1; 1 < 0; 1 < 1; 1 <= 0; 1 <= 1; doprovodný text

Výsledek FT TF TF TT FF FT 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; }


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 int main() { 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";


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; return 0; }

PŘEHLED: if (výraz)

pokud je podmínka splněna, vykoná se příkaz na dalším řádku, pokud není splněna

příkaz;

program jde na další řádek

další příkaz+ „Větvení ve dvou směrech“ if (výraz) příkaz 1; else

pokud je podmínka splněna, vykoná se příkaz 1, pokud není splněna vykoná se příkaz 2 musí nastat jedna z možností

příkaz 2; další příkaz; 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.


doprovodný text

str. 21/52

LOGICKÉ OPERÁTORY AND (zároveň) OR (nebo) NOT (negace;opak)

&& || !

výraz1 && výraz2 výraz1 || výraz2 !výraz

if (( x == 5) && (y == 5))

//AND; pokud není splněna 1. podmínka, kompilátor jde dál

if (( x == 5) || (y == 5))

//OR

if (!( x == 5))

//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:


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 float Prevod(float); int main() { 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; return 0; }


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 void mojeFunkce(); int main() { int x = 5; std::cout << "\nV main je hodnota x: " << x; mojeFunkce(); std::cout << "\nZpatky v main, hodnota x je: " << x; return 0; } 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 void zamena(int x, int y); int main() { 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"; return 0; } 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 void mojeFunkce();

// prototyp

int x = 5, y = 7; // globální proměnné int main() { 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"; return 0; } 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é.


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. 2. 3. 4.

Zkompiluji zdrojový kód Ctrl+F9 Umístím breakpointy na řádky ve zdrojovém kódu pomocí Ctrl+F5 Spustím ladění F8 (Debug – Ladit) 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:


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 int main() { int citac = 0;

// inicializace podmínky podmínka

while(citac < 5) // test, zda je podmínka stále pravdivá { citac++; // tělo smyčky std::cout << "citac: " << citac << "\n"; }

+ příkaz

std::cout << "Hotovo, citac: " << citac << ".\n"; char reakce; cin>>reakce; return 0; }

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; }


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 int main() { int citac = 0; while (true) { citac ++; if (citac > 10) break; } std::cout << "Citac: " << citac << "\n"; char reakce; cin>>reakce; return 0; }

příkaz

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.

podmínka

+ do příkaz; while (podmínka);


doprovodný text

str. 28/52

-

//Program demonstruje smyčku do while #include int main() { 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; return 0; }

Smyčka for

for ( inicializace; test+ akce ) příkaz;

// Smyčka for #include int main() { int citac; for (citac = 0; citac < 5; citac++) std::cout << "Smycka! "; std::cout << "\nCitac: " << citac << ".\n"; char reakce; cin>>reakce; return 0; }


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:

prikaz;

case druhaHodnota: … case ntaHodnota: default: }

prikaz; prikaz; prikaz;


doprovodný text

str. 30/52

// Ukázka příkazu switch #include int main() { 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"; break; default: cout << "Vlozil jsi cislo vetsi nez 5!\n"; break; } cout << "\n\n"; char reakce; cin>>reakce; return 0; } ------------------------------------------------------------------------------------------------------------------------------

Poznámky:


doprovodný text

str. 31/52

7. díl


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 int main() 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.


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 //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::

int main() { //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";

hlavní část programu

double u, r, i;

definice proměnných

výpis na obrazovku

int volba; //nabídkové menu cout << "\nTvoje volba: 1-vypocita napeti, 2-vypocita odpor, 3-vypocita proud\n"; cin >> volba; switch (volba)

na vstupu proměnná volba větvení programu podle hodnoty

proměnné { 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: Základy programování v jazyce C++

proměnná má hodnotu 3 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; return 0; }

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).


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:


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 int main() { int mojePole[10]; int i; for ( i=0; i<10; i++) // 0-9 //na vstupu 10 prvků pole { std::cout << "Hodnota mojePole[" << i << "]: "; std::cin >> mojePole[i]; } for (i = 0; i<10; i++) //výstup na obrazovku std::cout << i << ": " << mojePole[i] << "\n"; return 0; } Inicializace polí 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!


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];


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; return 0; }

Ú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:

int main() { 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; return 0; }


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

int main() { 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; return 0; }

Program pro kopírování řetězců, metoda strcpy() #include //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:: int main() { //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; return 0; }

Poznámky:


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ý. 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.


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

Podmíněný výraz

c = a + b;

if (podmínka) { blok příkazů }

Cyklus s určeným počtem opakování

Cyklus s podmínkou na konci

for (inicializace, podmínka, přírůstek) { blok příkazů; }

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á;


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


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


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:


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.


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:


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 typedef unsigned short int USHORT; int main() { using std::cout; using std::cin; USHORT mujVek; USHORT *ukVek;

// proměnná // 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; return 0; } 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.


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

int main() { 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; return 0; }

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 int main() { 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; return 0; } Základy programování v jazyce C++

doprovodný text

str. 52/52

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

Recommend Documents