Programování C++ Lukáš Tomášek lukast@centrum.cz verze 1.2 01.03.2013
Obsah: 1. Úvod, historie C a C++... 3 2. Základy C++... 4 2.1. Struktura programu... 4 2.2. Proměnné a základní datové typy... 5 2.3. Pole... 12 2.4. Sekvence znaků... 13 2.5. Textové řetězce typu string... 14 2.6. Struktury... 14 2.7. Operátory... 15 3. Řídící struktury... 20 3.1. Podmínky (if-else, switch)... 20 3.2. Cykly (while, do-while, for)... 21 4. Práce s ukazateli (pointery), dynamické přidělování paměti... 23 5. Funkce a procedury... 25 6. Práce se soubory čtení, zápis... 27 7. Objektově orientované programování - třídy... 28 8. Použitá literatura, odkazy... 30 2
1. Úvod, historie C a C++ Programovací jazyky se vyvíjely spolu s vývojem počítačů. V první generaci jazyků programátor pracoval výhradně se strojovým kódem počítačů. Dále vedl vývoj přes jazyky symbolických adres (assemblery) přesně kopírující instrukční soubory procesorů k vyšším jazyky, které jsou tvořeny sadou příkazů (C, C++, Pascal, Java). 1972 C Programovací jazyk C byl navržen Dennisem Ritchiem začátkem 70. let při vývoji operačního systému Unix. Jedná se o strukturovaný jazyk, který se velmi často používá při návrhu operačních systémů a aplikací, je populární i na akademické půdě. 1982-85 C++ Když vzrostla obliba objektově-orientovaného programování (OOP), byla definice "céčka" rozšířena Bjarne Stroustrupem. C++, jak se rozšířená definice jazyka C nazývá, je pravděpodobně nejpoužívanější programovací jazyk pro tvorbu rozsáhlých programů. 2000-02 C# Anders Hejlsberg, Microsoft, základní jazyk architektury.net. 3
2. Základy C++ 2.1. Struktura programu První ukázkový program Hello World, který vypisuje na obrazovku zprávu Hello World! V bílém poli je zdrojový kód programu a v šedém pak jeho výpis na obrazovku, když program zkompilujeme a spustíme: // Program vypisující Hello World na obrazovku (komentář na jeden řádek) /* Program vypisující Hello World na obrazovku (komentář na více řádků) */ #include <iostream> // vkládá knihovnu, kde je definována funkce cout using namespace std; // standardní jmenný prostor int main() { cout << "Hello World!" << endl; // vypíše na obrazovku Hello World! return 0; Hello World! Probereme si postupně předchozí kód řádek po řádku: // Program vypisující Hello World na obrazovku (komentář na jeden řádek) /* Program vypisující Hello World na obrazovku (komentář na více řádků) */ Toto jsou komentáře (jednořádkový začínající // a víceřádkový začínající /* a končící */ ). Komentáře jsou oblast kódu, která není překládána a nemá tedy vliv na chování programu. Jsou to textové poznámky, které programátoři do kódu vkládají, aby s jejich pomocí podrobněji objasnili jeho funkčnost. #include <iostream> Řádky začínající # jsou příkazy (direktivy) pro preprocesor. Direktiva #include vkládá tzv. hlavičkové soubory použité při překladu programu. Hlavičkové soubory obsahují funkce a konstanty, které můžeme v kódu dále použít. Konkrétně #include <iostream> vkládá soubor iostream ze standardní knihovny, jež definuje funkce související se standardním vstupem a výstupem. 4
using namespace std; Tento příkaz určuje takzvaný jmenný prostor, v němž jsou deklarovány všechny elementy standardní C++ knihovny. V tomto případě se jedná o jmenný prostor standardní knihovny (std::). int main() Tento řádek určuje začátek definice hlavní funkce main(). Funkce je skupina více souvisejících příkazů, které slouží v provedení nějakého úkolu. Každá funkce má jméno, kterým se volá, v tomto případě se volá funkce main. Kulaté závorky za názvem funkce () mohou obsahovat vstupní parametry dané funkce. Všechny příkazy určité funkce jsou uvedené v takzvaném těle funkce, které začíná levou závorkou { a končí pravou závorkou. Každý příkaz končí středníkem, příkazy se provádí popořadě odshora dolů. Programy mívají funkcí víc, ale každý program v C++ má právě jednu hlavní funkci main, která je vstupním bodem daného programu. cout << "Hello, world!" << endl; Zde cout je výstupní datový proud na standardní výstupní zařízení, nejčastěji na obrazovku. Operátor << určuje směr přesměrování toku dat za své pravé strany, endl ukončuje řádek. V tomto případě se tedy přesměruje textový řetězec "Hello World!" na obrazovku a kurzor se přesune na nový řádek. return 0; Tento příkaz způsobí ukončení hlavní funkce main. Příkaz return může být následován návratovou hodnotou (v našem případě 0, což u většiny programů znamená, že skončil bez chyby). 2.2. Proměnné a základní datové typy K uložení určitých dat definujeme tzv. proměnou, což je část paměti počítače určená k uložení hodnoty určitého typu. Každá proměnná je definována unikátním jménem, neboli identifikátorem, které ji odlišuje od ostatních proměnných v programu. Identifikátory Platný identifikátor (název proměnné) je posloupnost jednoho či více písmen, číslic a podtržítek (_). Nesmí obsahovat jiné znaky jako mezery, vykřičníky, tečky atp. a dále standardní rezervovaná slova v C++. Pozor: Jazyk C++ rozlišuje velká a malá písmena, to znamená, že identifikátor napsaný velkými písmeny není totožný se stejným názvem napsaný malými písmeny!! Tedy např. proměnná cislo není totožná s proměnnou Cislo, CISLO, CiSlo (všechny uvedené identifikátory jsou rozdílné). 5
Základní datové typy Při programování ukládáme proměnné do paměti počítače, tudíž počítač musí vědět, jaký typ dat do určité proměnné chceme ukládat. Neboť třeba jednouché písmeno zabere méně paměti než velké číslo a navíc každý datový typ je jinak interpretován (např. číslo jinak než text). Paměť v počítači je organizována v tzv. bytech (bajtech), což je nejmenší část paměti, se kterou může C++ pracovat. Byte zkratka B, sestávající z 8 bitů, obsahuje relativně malý objem dat: jeden textový znak nebo celé kladné číslo v rozsahu 0 a 255. Kromě toho tedy počítač manipuluje s více komplexními datovými typy jako se seskupeními několika bytů, např. velká celá čísla nebo reálná čísla s desetinnou čárkou. Zde je výčet základních datových typů v C++ spolu s rozsahem hodnot, kterých mohou nabývat: Název datového typu Popis Velikost* Rozsah* # char znak nebo malé celé číslo 1 B signed: -128 až 127 unsigned: 0 až 255 short int krátké celé číslo signed: -32768 až 32767 2 B (short) short integer unsigned: 0 až 65535 signed: -2147483648 až int celé číslo integer 4 B 2147483647 unsigned: 0 až 4294967295 long int (long) dlouhé celé číslo - long integer 4 B. signed: -2147483648 až 2147483647 unsigned: 0 až 4294967295 bool logická hodnota Boolean. true, false (pravda, 1 B true, false nepravda) float desetinné číslo s pohyblivou čárkou - Floating point 4 B +/- 3.4e +/- 38 (~7 číslic) double desetinné číslo s pohyblivou čárkou se zvýšenou přesností - Double precision floating 8B +/- 1.7e +/- 308 (~15 číslic) point long double Long double precision floating point 8B +/- 1.7e +/- 308 (~15 číslic) wchar_t rozšířený znak - Wide charakter 2 nebo 4 B 1 rozšířený znak * Hodnoty velikostí a rozsahy záleží na typu systému, na kterém je program kompilován. V tabulce jsou uvedeny typické hodnoty pro většinu 32 bitových systémů. # signed číslo se znaménkem (kladné i záporné hodnoty), unsigned bez znaménka (pouze kladné hodnoty) 6
Deklarace proměnných Deklarace proměnné, syntaxe: datový_typ identifikátor_proměnné; Příklad: int a; float moje_cislo; Jakmile je proměnná deklarována, může být použita ve svém rozsahu platnosti v programu. Více proměnných stejného typu může být deklarováno najednou, když oddělíte jejich identifikátory čárkou, např.: int a, b, c; je totéž jako: int a; int b; int c; Celočíselné datové typy char, short, long a int mohou být buď signed (pozitivní i negativní hodnoty) nebo unsigned (pouze pozitivní hodnoty a nula). Pokud není uveden typ či znamékový rozsah, defaultní hodnota je int a signed, tj. unsigned short int pocet; signed int zisk; signed int rozdil; int rozdil; // totéž jako signed int rozdil unsigned int zisk; unsigned zisk; // totéž jako unsigned int zisk Příklad na deklarace a použití proměnných: // Příklad - Deklarace a použití proměnných #include <iostream> 7
using namespace std; int main () { // deklarace proměnných: int a, b; int vysledek; // přířazení a výpočet hodnot: a = 3; b = 5; a = a + 2; vysledek = (a b)*2; // vypsání vysledku: cout << "Vysledek = " << vysledek; // konec programu: return 0; Vysledek = 6 Rozsah platnosti proměnných Všechny proměnné musí být deklarovány před tím, než jsou v programu použity. Proměnná může mít buď globální, nebo lokální rozsah platnosti uvnitř programu. Globální proměnná je deklarována v hlavním těle zdrojového kódu mimo všechny funkce, zatímco lokální proměnná je deklarována uvnitř těla funkce nebo bloku. // Příklad - Globální a lokální proměnné #include <iostream> using namespace std; // deklarace globálních proměnných int x, y; int main () { // deklarace lokálních proměnných: int rozdil; x = 2; y = 5; rozdil = x - y; cout << "Rozdil =" << vysledek; Rozsah platnosti lokálních proměnných Rozsah platnosti globálních proměnných return 0; Rozdil = -3 8
Na globální proměnné se můžeme odkazovat kdekoli v kódu za jejich deklarací, dokonce i uvnitř funkcí. Rozsah platnosti lokálních proměnných je limitován na blok uzavřený v závorkách {, kde jsou deklarovány. Pokud jsou tedy deklarovány například uvnitř nějaké funkce, jsou přístupné pouze uvnitř této funkce a ne mimo ni. Inicializace proměnných Když deklarujeme proměnnou jako v předchozích příkladech, její hodnota není definována. Pokud chcete definovat počáteční hodnotu nějaké proměnné už v momentu její deklarace, je možno použít inicializaci proměnné už při deklaraci. V C++ je to možné udělat dvěma způsoby: postaru jako v C: Například: nově v C++: Například: typ identifikátor = počáteční_hodnota; int a=0; typ identifikátor(počáteční_hodnota); int a(0); Oba způsoby jsou v C++ ekvivalentní. // Příklad - Inicializace proměnných #include <iostream> using namespace std; int main () { int a=3; // počáteční hodnota = 3 int b(4); // počáteční hodnota = 4 int vysledek; // počáteční hodnota není determinována a = a + 3; vysledek = a - b; cout << "Vysledek = " << vysledek; return 0; Vysledek = 2 9
Konstanty Konstanty jsou výrazy s konstantní hodnotou. Jejich hodnotu nelze měnit. Musíme ji tedy přiřadit do proměnných již při inicializaci pomocí operátoru přiřazení: const int a = 5; Celá čísla // integer 101-54 12 // decimálně 014 // oktalově, začíná 0 0xc // hexadecimálně, začíná 0x 13 // int 13u // unsigned int 13l // long 13ul // unsigned long Desetinná čísla 5.26 // 5.26 standardně typ double 4.12e15 // 4.12 x 10^15 2.16e-7 // 2.16 x 10^-7 // Standardní typ pro desetinná čísla je typ double, jinak: 8.123L // long double 2.64e9f // float Znaky a znakové řetězce Znak: 'a' Znakový řetězec: "Hello World" Formátovací znaky: '\n' nový řádek (Line Feed) '\r' na začátek řádku (Carriage Return) '\t' tabulator '\b' backspace '\a' pípnutí '\'' jednoduché úvozovky (') '\"' dvojité úvozovky (") '\?' otazník (?) '\\' zpětné lomítko (\) '\x40' jakýkoli znak pomocí ASCII hodnoty, (v tomto případě 0x40, tj. 60, což je @) 10
Příklad: cout<<"prvni radek\ndruhy radek\n"; totéž jako: cout<<"prvni radek"<<endl<<"druhy radek"<<endl; Boolean Jsou pouze dvě hodnoty typu Bool: true (pravda) a false (nepravda). bool pravda=true; bool nepravda=false; Definované konstanty (#define) Můžete definovat vlastní konstanty pro preprocesor pomocí direktivy #define identifikátor hodnota Pozor - nejde o C++ příkaz, ale pouze direktivu pro preprocesor, proto nekončí středníkem (;)! Příklad užití: // Příklad na definované konstanty: výpočet obvodu kruhu #include <iostream> using namespace std; #define PI 3.1416 #define NOVY_RADEK '\n' int main () { double polomer=2.5; // poloměr double obvod; obvod = 2 * PI * polomer; cout << "Obvod kruhu o polomeru "<<polomer<<" je: "<< obvod << NOVY_RADEK; return 0; Obvod kruhu o polomeru 2.5 je: 15.708 11
Deklarované konstanty (const) Pomocí předpony const je možno deklarovat v paměti konstanty podobným způsobem jako proměnné: const typ identifikátor=hodnota; const typ identifikátor(hodnota); const double pi=3.1416; // pí const bool pravda=true; const bool nepravda=false; Tyto konstanty se používají podobně jako proměnné, ale jejich hodnota nemůže být po jejich definici změněna (proto také musí být vložena už při definici). 2.3. Pole Pole je posloupnost prvků stejného typu umístěných souvisle v paměti. Jednotlivé prvky pole mohou být individuálně přístupné pomocí indexu uvedeného v hranatých závorkách za unikátním identifikátorem. Typická deklarace pro pole v C++ je: datový_typ název [počet_prvků]; kde počet prvků, které pole obsahuje, musí být konstantní hodnota, protože pole jsou nedynamický datový typ, jehož velikost musí být určena před spuštěním programu. Pokud je třeba vytvořit proměnnou délku pole, je třeba použít dynamicky alokovanou paměť, viz dále. int pole [5]; int pole [5] = {16, 2, 77, 40, 12071; // inicializace pole int pole [] = {16, 2, 77, 40, 12071; for(int i=0; i<10; i++){ pole[i]=i; for(int i=0; i<10; i++){ cout<<pole[i]<<, ; 12
2.4. Sekvence znaků Standardní knihovna C++ implementuje třídu string, která nabízí užitečné funkce s řetězci znaků (viz další kapitola). Nicméně protože jde o sekvenci znaků, můžeme je reprezentovat také jako pole elementů typu char. Např.: char slovo[20]; je pole, které do nějž můžeme uložit až dvacet znaků. Pokud bude sekvence znaků kratší než délka pole, k ukončení znakového řetězce je použit speciání znak null charakter ('\0'). Příklad identické inicializace: char myword[] = { 'H', 'e', 'l', 'l', 'o', '\0' ; char myword [] = "Hello"; Příklad: #include <iostream> using namespace std; int main () { char otazka[] = "Prosim, napiste sve jmeno: "; char pozdrav[] = "Dobry den, "; char vasejmeno[80]; cout << otazka; cin >> vasejmeno; cout << pozdrav << vasejmeno << "!"; return 0; Prosim, napiste sve jmeno: Lukas Dobry den, Lukas! Převod mezi poli typu char a řetězci typu string: string mujstring; char mujtext[]="nejaky text"; mujstring = mujtext; 13
2.5. Textové řetězce typu string Proměnným, do nichž se ukládají textové hodnoty delší než jeden znak, se říká textové řetězce. Standardní knihovna C++ poskytuje podporu pro práci s textovými řetězci v knihovně string. // Příklad na string #include <iostream> #include <string> using namespace std; int main () { string retezec = "Pocatecni hodnota stringu."; // totéž jako string retezec("počáteční hodnota stringu.") cout << retezec << endl; retezec = "Dalsi hodnota stringu."; cout << retezec << endl; return 0; 2.6. Struktury #include <iostream> #include <string> using namespace std; #define POCET_LIDI 2 struct TClovek{ string jmeno; string prijmeni; int roknarozeni; ; //Alternativni definice typu struct typedef struct{ string jmeno; string prijmeni; int roknarozeni; TClovek2; int main(){ TClovek clovek[pocet_lidi]; TClovek2 *uk_clovek=new TClovek2; 14
clovek[0].jmeno="pavel"; clovek[0].prijmeni="novak"; clovek[0].roknarozeni=1988; clovek[1].jmeno="marcela"; clovek[1].prijmeni="leva"; clovek[1].roknarozeni=1956; for(int i=0; i<pocet_lidi; i++) cout<<clovek[i].jmeno<<" "<<clovek[i].prijmeni<<" "<<clovek[i].roknarozeni<<endl; uk_clovek->jmeno="josef"; // totez jako (*uk_clovek).jmeno="josef"; uk_clovek->prijmeni="rambousek"; uk_clovek->roknarozeni=1901; cout<<uk_clovek->jmeno<<" "<<uk_clovek->prijmeni<<" "<<uk_clovek->roknarozeni<<endl; delete uk_clovek; return 0; Pavel Novak 1988 Marcela Leva 1956 Josef Rambousek 1901 2.7. Operátory Přiřazení (=) Operátor přiřazení přiřazuje hodnotu nějaké proměnné, např. int a, b; a = 5; // přiřazení hodnoty 5 do proměnné a b = a; // přiřazení hodnoty proměnné a do proměnné b Aritmetické operátory ( +, -, *, /, % ) + Součet - Rozdíl * Násobení / Dělení % modulo (zbytek po dělení) Příklad na celočíselné dělení: int deleni = 17 / 3; // deleni=3, neboť 17=3*5+2 15
int zbytek = 17 % 3; // zbytek=2, neboť 17=3*5+2 Sloučené přiřazení (+=, -=, *=, /=, %=, >>=, <<=, &=,^=, =) Zkrácený ekvivalentní zápis hodnota += prirustek; hodnota = hodnota + prirustek; a += 5; //ekvivalentní s: a = a + 5; a /= b; //ekvivalentní s: a = a / b; a podobně pro ostatní operátory. Inkrement a dekrement (++, --) Zkrácený zápis pro přičítání (inkrement) a odčítání (dekrement) jedničky v nějaké proměnné, tj. +=1 a -=1, např.: a++; // totéž jako a+=1; a tedy i jako a=a+1; b--; // totéž jako b-=1; a tedy i jako b=b-1; Pozor existují dvě varianty (++b) a (b++), obě zvýší hodnotu b o 1, ale pokud jsou tyto výrazy použity při přiřazení, tak první varianta (++b) nejdřív inkrementuje a pak přiřadí hodnotu, druhá varianta (b++) nejdřív přiřadí hodnotu, pak inkrementuje, tj.: a=2; b=++a; // a je 3, a je 3 a=2; b=a++; // a je 3, b je 2!! Relační operátory ( ==,!=, >, <, >=, <= ) Jejich výsledkem je logická pravda (true) nebo nepravda (false) == Rovná se!= Nerovná se > Větší než < Menší než >= Větší nebo rovno než <= Menší nebo rovno než Příklady: (2 == 2) // true (4 > 5) // false (5!= 3) // true (1 >= 1) // true 16
(1 < 1) // false a=1; b=2; (a > 3 ) // false (a < b) // true Pozor na častou a chybnou záměnu = a ==!! Logické operátory (!, &&, ) Operator! je logická negace, tj.!true // je false!false // je true!(2==2) //je false Operátor logického součin (AND) && a b a && b true true true true false false false true false false false false Operátor logického součtu (OR) a b a b true true true true false true false true true false false false Příklad: ((3 == 2) && (3 > 1)) // je false (false && true) ((3 == 2) (3 > 1)) // je true (false true) Bitové operátory ( &,, ^, ~, <<, >> ) Umožňují manipulovat s binárními hodnotami přímo na úrovni jednotlivých bitů. Operátor Zkratka Popis & AND bitový součin AND OR bitový součet OR ^ XOR bitový exkluzivní OR (nonekvivalence) ~ NOT bitová negace (doplněk) << SHL posun vlevo >> SHR posun vpravo 17
Operátor explicitního přetypování Před identifikátorem proměnné, jejíž hodnotu ve výrazu chceme přetypovat, použijeme v kulatých závorkách nový typ: (nový_typ) proměnná int i; double d = 2.689; i = (int) d; // je 2, nebo totéž: i = int (d) pozor na přetečení rozsahu!! d = d/i; //1.3445 i=5; d = i/2; // pozor je 2!!! d= (double) i/2; // 2.5 sizeof() Tento unární operátor přijímá pouze jeden parametr, kterým může být typ nebo identifikátor proměnné, a vrací velikost v bytech, jež proměnná či typ zabírá v paměti. int i, velikost; int velikost = sizeof (i); // jsou 4 (byty) cout << velikost<<endl; velikost = sizeof (int); // 4 (byty) velikost = sizeof(char); // 1 (byte) Pozor - hodnota, kterou vrací sizeof je konstanta, která je vyhodnocena ještě před během programu! Priorita operátorů Při psaní složitých výrazů s více operandy si musíme dát pozor na pořadí jejich vyhodnocování podle priority jednotlivých operátorů: x = 2 + 3 * 4; // je 14 y = (2 + 3) * 4; // je 20 Pokud je třeba, nebo je výraz příliš nepřehledný, je vždy lepší použít k jasnému určení pořadí vyhodnocení kulaté závorky. 18
Úroveň Pořadí Operátor Popis priority vyhodnocení 1 max. :: scope zleva 2 () []. -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid 3 ++ -- ~! sizeof new delete * & + - postfix unary (prefix) indirection, reference (pointers) unary sign operator zleva zprava 4 (type) type casting zprava 5 * ->* pointer-to-member zleva 6 * / % multiplicative zleva 7 + - additive zleva 8 << >> shift zleva 9 < > <= >= relational zleva 10 ==!= equality zleva 11 & bitwise AND zleva 13 bitwise OR 12 ^ bitwise XOR zleva zleva 14 && logical AND 15 logical OR zleva zleva 16?: conditional zprava 17 = *= /= %= += -= >>= <<= &= assignment ^= = zprava 18 min., comma zleva 19
3. Řídící struktury 3.1. Podmínky (if-else, switch) Komplexní program obvykle není jen jednoduchá lineární sekvence příkazů, ale je třeba na základě nějakých vstupních parametrů opakovat, či vykonávat různé části kódu. Pro tyto případy poskytuje C++ různé řídící struktury. Podmínka: if else if (podmínka) { příkazy... else if (podmínka) { příkazy... else { příkazy... if (i==1) cout << "jedna" << endl; else if (i==2) cout << "dve" << endl; else cout << "jine nez 1 nebo 2" << endl; if (1<2) cout << "tato podminka je splnena" << endl; if (1>2) cout << "tato podminka neni splnena" << endl; Větvení (switch) int i=1; switch (i) { case 0: cout << "nula"; break; case 1: cout << "jedna"; break; case 2: cout << "dve"; break; default: cout<< "jine nez 0,1,2"; Jedna 20
3.2. Cykly (while, do-while, for) Cyklus while while ( podmínka ) { příkazy... int i=0; while(i<10) { cout<<i<<" "; i++; 0 1 2 3 4 5 6 7 8 9 Cyklus do-while do { příkazy... while ( podmínka ); int i=0; do { cout<<i<<" "; i++; while(i<10); 0 1 2 3 4 5 6 7 8 9 21
Cyklus for for(deklarace počítací proměnné ; podmínka ; počítání ) { příkazy for(int i=0; i<10; i++) { cout<<i<<" "; 0 1 2 3 4 5 6 7 8 9 Příkaz break int i=0; while(1) { cout<<i<<" "; if(i==9) break; // vyskoceni z cyklu i++; 0 1 2 3 4 5 6 7 8 9 Příkaz continue for(int i=0; i<10; i++) { if(i==5) continue; // navrat na zacatek cyklu cout<<i<<" "; 0 1 2 3 4 6 7 8 9 22
4. Práce s ukazateli (pointery), dynamické přidělování paměti Ukazatel (pointer) Ukazatel je proměnná, která ukazuje na jinou proměnnou nebo konstantu. Jeho hodnotou je adresa obsahu této proměnné v paměti. Operator reference (&) Používá se na nastavení ukazatele na adresu proměnné adresu proměnné vrátí adresovací operátor (reference) &. Operátor dereference (*) Operátor dereference * použitý před proměnnou typu ukazatel slouží k dereferencování ukazatelů. Jeho hodnotou je hodnota, na kterou ukazatel ukazuje. Dynamické přidělování a uvolnění paměti operátor new a delete Dynamické přidělování paměti za běhu programu se provádí pomocí operátoru new. Když už paměť není potřeba, je nutné ji uvolnit pomocí operátoru delete. Např. int *uk_int= new int; //dynamické vytvoření proměnné typu int delete uk_int; // uvolnění proměnné z paměti, když už není potřeba Pole: int *uk_pole[100]=new int[100]; //dynamické vytvoření pole o 100 prvcích typu int delete [] uk_pole; // uvolnění pole z paměti, když už není potřeba int cislo=5; // statické vytvoření proměnné typu celé číslo int *ukazatel=&cislo; // vytvořeni ukazatele na cele číslo a přiřazení adresy na kterou ukazuje cout<<"cislo="<<cislo<<endl; cout<<"ukazatel="<<ukazatel<<endl; cout<<"*ukazatel="<<*ukazatel<<endl; *ukazatel=2; // nastaveni hodnoty na adrese na kterou ukazatel ukazuje cout<<"cislo="<<cislo<<endl; cout<<"ukazatel="<<ukazatel<<endl; cout<<"*ukazatel="<<*ukazatel<<endl; 23
ukazatel = new int; // přidělení (vytvoření) nového celého čísla cout<<"ukazatel="<<ukazatel<<endl; cout<<"*ukazatel="<<*ukazatel<<endl; *ukazatel=3; // nastaveni hodnoty na adrese na kterou ukazatel ukazuje cout<<"*ukazatel="<<*ukazatel<<endl; delete(ukazatel); // uvolněni z pameti cislo=5 ukazatel=0012ff60 *ukazatel=5 cislo=2 ukazatel=0012ff60 *ukazatel=2 ukazatel=003e5bf0 *ukazatel=-842150451 *ukazatel=3 24
5. Funkce a procedury Kód, který se často opakuje nebo opakovaně používá, můžeme vložit do tzv. funkcí (vrací hodnotu) nebo procedur (nevrací žádnou hodnoty, typ void). Funkce může mít více vstupních proměnných (argumentů) předávaných hodnotou, data může vracet přes návratovou hodnotu nebo přes argumenty předávané ukazatelem nebo odkazem. #include <iostream> using namespace std; // procedura nic nevrací void pozdrav(){ cout << "ahoj" << endl; // funkce vrací hodnotu int soucet(int a, int b){ return(a+b); // rekurzivni funkce volá sama sebe int faktorial(int cislo){ if(cislo == 1) return 1; return (faktorial(cislo-1) * cislo); // předávání výsledku přes ukazatel int deleniukazatel(double a, double b, double *vysledek){ if(b==0) return(-1); *vysledek=a/b; return 0; // předávání výsledku přes odkaz int deleniodkaz(double a, double b, double &vysledek){ if(b==0) return(-1); vysledek=a/b; return 0; int main(){ double a=5.0; double b=3.0; double vysledek; int status; 25
pozdrav(); cout << soucet(1,2) << endl; cout << faktorial(5) << endl; status=deleniukazatel(a, b, &vysledek); cout << "vysledek_deleniukazatel: " <<vysledek<<endl; a=3.0; b=2.0; status=deleniodkaz(a, b, vysledek); cout << "vysledek_deleniodkaz: " <<vysledek<<endl; return 0; ahoj 3 120 vysledek_deleniukazatel: 1.66667 vysledek_deleniodkaz: 1.5 26
6. Práce se soubory čtení, zápis Příklad zápisu a čtení ze souboru pomocí standardní cpp knihovny <fstream> : #include <iostream> #include <string> #include <fstream> //standardni cpp knihovna pro praci se soubory using namespace std; #define SOUBOR "clovek.txt" int main(){ //zapis do souboru fstream soubor; // vystupni proud do souboru (zapis) soubor.open(soubor, fstream::out); //otevreni souboru, par. out - prepis souboru soubor << "Lukas" << endl << "Tomasek" << endl << 1970<<endl; soubor.close(); //uzavreni souboru //zapis do souboru - pridani na konec soubor.open(soubor, fstream::app); //otevreni souboru, app - pripojeni na konec soubor << "Pavel" << endl << "Novy" << endl << 1969; soubor.close(); //uzavreni souboru string jmeno, prijmeni; int roknarozeni; //cteni ze souboru soubor.open(soubor, fstream::in); //parametr in - otevreni souboru pro cteni while(!soubor.eof()){ //overeni konce souboru soubor >> jmeno >> prijmeni >> roknarozeni; //nacteni dat ze souboru cout<<jmeno<<" "<<prijmeni<<" "<<roknarozeni<<endl; //vypis dat na obrazovku soubor.close(); //uzavreni souboru return 0; Lukas Tomasek 1970 Pavel Novy 1969 27
7. Objektově orientované programování - třídy #include <iostream> using namespace std; #define PI 3.14159 class Kruh{ private: //privatni data (ci funkce) tridy - pristupne pouze ze clenskych funkci teto tridy double polomer; public: // public data (ci funkce) - jsou pristupne pro uzivatele teto tridy Kruh(double r=0); // konstruktor tridy - vola se pri vzniku instance tridy // clenske funkce tridy ; double getpolomer() { return polomer; double obvod() { return(2*pi*polomer); double obsah() { return(pi*polomer*polomer); int setpolomer(double r); int Kruh::setPolomer(double r){ if(r<0) { cout<<"chyba: Polomer "<<r<<"je zaporny!!"<<endl; return(-1); else{ polomer=r; return(0); Kruh::Kruh(double r){ setpolomer(r); //************************************************ int main(){ Kruh k1(2.5); // konkretni instance tridy Kruh s nazvem k1 o zadanem polomeru 2.5 Kruh *k2=new Kruh(3.3); // dalsi instance tridy (dynamicka alokace pameti) Kruh k3; // instance k3 o neurcenem polomeru, tj. 0 cout<<"obvod kruhu k1 s polomerem "<< k1.getpolomer()<<"="<< k1.obvod()<<endl; 28
cout<<"obsah kruhu k1 s polomerem "<< k1.getpolomer() <<"="<< k1.obsah() <<endl; k1.setpolomer(4.0); cout<<"obvod kruhu k1 s polomerem "<< k1.getpolomer()<<"="<< k1.obvod()<<endl; cout<<"obsah kruhu k1 s polomerem "<< k1.getpolomer()<<"="<< k1.obsah() <<endl; cout<<"obvod kruhu k2 s polomerem "<< k2->getpolomer()<<"="<< k2->obvod()<<endl; cout<<"obsah kruhu k2 s polomerem "<< k2->getpolomer()<<"="<< k2->obsah() <<endl; delete k2; // uvolneni z pameti return 0; Obvod kruhu k1 s polomerem 2.5=15.708 Obsah kruhu k1 s polomerem 2.5=19.6349 Obvod kruhu k1 s polomerem 4=25.1327 Obsah kruhu k1 s polomerem 4=50.2654 Obvod kruhu k2 s polomerem 3.3=20.7345 Obsah kruhu k2 s polomerem 3.3=34.2119 29
8. Použitá literatura, odkazy [1] Juan Soulié - C++ Language Tutorial (cplusplus.com, 2007) [2] Jeff Kent - C++ bez předchozích znalostí (Computer Press, Brno 2011) [3] Karel Mozdřeň - Programování v C++, První kroky (http://homel.vsb.cz/~moz017, 2009) [4] Wikipedie.cz 30