V dalších letech se pak začaly objevovat první normy pro jazyk C++ (ISO/IEC 14882:1998; ISO/IEC 9899:1999; ISO/IEC 14882:2003; ISO/IEC 14882:2011).

Transkript

1 Jazyk C++ 1 Blok 1 Úvod do programovacího jazyka C++ Studijní cíl První blok kurzu je věnován úvodu do problematiky programovacího jazyka C++. V bloku budou rozebrány historické souvislosti programovacích jazyků C a C++ a budou představeny a zhodnoceny základní technologie, které se této oblasti dotýkají. Po absolvování bloku bude student ovládat základní pojmy z oblasti programování v jazyce C++. Doba nutná k nastudování 2-3 hodiny Průvodce studiem Pro studium tohoto bloku jsou u studentů požadovány předchozí znalosti z oblasti programování v jazyce C. Pro úspěšné zvládnutí bloku se u studentů předpokládá základní znalost běžných výpočetních prostředků a principů programování (počítač, vývojové prostředí, zdrojový kód, ). Historie Dalo by se říci, že jazyk C++ je objektově orientovaným rozšířením jazyka C. Autorem programovacího jazyka C++ je dánský programátor, informatik a profesor na Texas A&M University Bjarne Stroustrup. V roce 1982 Stroustrup rozšířil jazyk C o objekty pomocí preprocesoru a nazval jej C s třídami (C with classes). První verze C++ se pak objevila v roce V dalších letech se pak začaly objevovat první normy pro jazyk C++ (ISO/IEC 14882:1998; ISO/IEC 9899:1999; ISO/IEC 14882:2003; ISO/IEC 14882:2011). Deklarace a definice Deklarace (informativní deklarace) informuje překladač o existenci nějakého objektu. Jazyk C++ 1 1

2 Definice (definiční deklarace) přikazuje překladači vytvořit daný objekt. Neobjektové rozdíly mezi C a C++ Identifikátory Délka identifikátoru (např. název proměnné) v C++ není dle normy omezena a všechny znaky jsou v něm signifikantní (významné). V jazyce C je signifikantních pouze 31 znaků. Překladače však mívají délky identifikátoru v C++ omezeny. Ve vývojovém prostředí Microsoft Visual C++ je signifikantních implicitně 247 znaků. Komentáře V jazyce C++ lze použít klasických C komentářů /* Komentáře na více řádcích. */ Podle nových norem lze uvádět jak v jazyce C, tak i v jazyce C++ také komentáře jednořádkové. // jednořádkový komentář Víceřádkové komentáře ale nelze podle normy vnořovat do sebe. Příkazy Za příkaz lze považovat také informativní i definiční deklaraci. To znamená, že deklarace se může vyskytnout na všech místech, kde syntaxe jazyka umožňuje příkaz. Rozdíl oproti jazyku C je vidět převážně u složených příkazů, tzv. bloků. V jazyce C++ je blok definován takto: {posloupnost_příkazůnep V jazyce C je potom blok definován následovně: {posloupnost_deklaracínep posloupnost_příkazůnep Příklad int pole[10]; pole[5] = 10; int x = pole[5]*2; // v jazyce C++ korektní zápis Deklarace proměnné je také povolena ve výrazu podmínka v příkazech: if(podmínka) příkaz Jazyk C++ 1 2

3 if(podmínka) příkaz else příkaz2 switch(podmínka) příkaz while(podmínka) příkaz for(inicializace; podmínka; výraz) příkaz V případě, že se jedná o cyklus for, může být proměnná deklarována též v části inicializace. Podle normy by měla být proměnná deklarovaná v těchto příkazech vždy proměnnou lokální. Ale často záleží na konkrétním překladači. Pozor, proměnnou nelze deklarovat v cyklu do příkaz while (výraz); v části výraz. Příklad if(int a = f()) Zpracuj(a); // OK b = a; // Chyba! Proměnná a už neexistuje. for(int i = 0; i < 10; i++) a[i] = i; // OK b = i; // Chyba! Proměnná i už neexistuje. Skoky Příkazů goto a switch se týká omezení možnosti přeskočit definici s inicializací, pokud nedojde k přeskočení celého bloku, v němž se tento příkaz vyskytuje. Chybný zápis if(true) goto Pokracovani; int a = 1; // Pokracovani: // Korektní zápis if(true) goto Pokracovani; int a; a = 1; // Pokracovani: // Jazyk C++ 1 3

4 Korektní zápis if(true) goto Pokracovani; { int a = 1; // Pokracovani: // Chybný zápis switch(a) { case 0: int x = 1; // break; case 1: // Korektní zápis switch(a) { case 0: int x; x = 1; // break; case 1: // Korektní zápis switch(a) { case 0: { int x = 1; // break; case 1: // Jazyk C++ 1 4

5 Datové typy Celočíselné typy Logický typ Pro logické hodnoty (pravda, nepravda) je v jazyce C++ k dispozici datový typ bool, který může nabývat hodnot true nebo false. Přičemž platí vztah true > false. Pokud překladač na místě, kde očekává logickou hodnotu, narazí na celé číslo, reálné číslo či znak, automaticky jej konvertuje, a to: libovolné nenulové číslo => true, nulu => false. Pokud překladač na místě, kde očekává číselnou hodnotu, narazí na hodnotu logickou, automaticky ji konvertuje: true => 1, false => 0. Znakové typy Jazyk C++ zná jednobytové znakové typy char, signed char a unsigned char a dvoubytový typ wchar_t, který lze použít pro práci s UNICODE a znaky asijských jazyků. Na rozdíl od programovacího jazyku C, kde jsou znakové konstanty (např. a ) typu int, jsou v programovacím jazyce C++ znakové konstanty typu char. Pokud se znakové konstanty zapisují s prefixem L (např. L a ), bude tato konstanta typu wchar_t. Znaková konstanta v UNICODE se zapisuje \Uxxxxxxxx nebo \uxxxx, kde x představuje číslici šestnáctkové soustavy. Zápis \uxxxx je potom zkratkou pro \U0000xxxx. Pro práci s dvoubytovými znaky (wide characters) se používají funkce s prefixem w, např. wprintf. Typy pro celá čísla V jazyce C++ jsou k dispozici velké datové typy long long int a unsigned long long int, přičemž int lze vynechat. Rozsah těchto typů nesmí být menší než rozsah long int a unsigned long int. V prostředí Microsoft Visual Studio C++ jsou tyto typy 8bytové. Jejich rozsahy jsou tedy následující: Jazyk C++ 1 5

6 long long int /2 až 2 64 /2-1 unsigned long long int 0 až Další celočíselné typy jsou: s přesně určenou šířkou: o znaménkové: int8_t, int16_t, int32_t, int64_t o bezznaménkové: uint8_t, uint16_t, uint32_t, uint64_t s minimální šířkou alespoň N bitů: o znaménkové: int_least8_t, int_least16_t, int_least32_t, int_least64_t o bezznaménkové: uint_least8_t, uint_least16_t, uint_least32_t, uint_least64_t s minimální šířkou a nejrychlejším výpočtem: o znaménkové: int_fast8_t, int_fast16_t, int_fast32_t, int_fast64_t o bezznaménkové: uint_fast8_t, uint_fast16_t, uint_fast32_t, uint_fast64_t typy, do nichž lze uložit void* o znaménkové: intptr_t o bezznaménkové: uintptr_t s maximální šířkou o znaménkové: intmax_t o bezznaménkové: uintmax_t Hlavičkový soubor <stdint.h> obsahuje také definice maker, poskytující minimální a maximální hodnoty konkrétních typů: INTN_MIN, INTN_MAX, UINTN_MAX (např. INT16_MAX) INT_LEASTN_MIN, INT_LEASTN_MAX, UINT_LEASTN_MAX (např. INT_LEAST16_MAX) INT_FASTN_MIN, INT_FASTN_MAX, UINT_FASTN_MAX (např. INT_FAST16_MAX) INTPTR_MIN, INTPTR_MAX, UINTPTR_MAX INTMAX_MIN, INTMAX_MAX, UINTMAX_MAX Ve vývojovém prostředí Microsoft Visual Studio C++ celočíselné znaménkové typy s přesně určenou šířkou, které lze používat ve spojení s modifikátorem unsigned: int8, int16, int32, int64 Jazyk C++ 1 6

7 Celočíselný konstantní výraz Jedná se o výraz, který dokáže překladač vyhodnotit už v době překladu. Jako operand v takovém výrazu lze použít: literál (Představuje pevně danou hodnotu, vyjádřenou explicitně, bez použití jiných prvků jazyka. Mezi literály tedy nepatří proměnné programu ani konstanty, naopak k inicializaci jejich hodnot se zpravidla literály používají.), makro, konstanta deklarovaná pomocí const inicializovaná konstantním výrazem, výčtová konstanta, operátor sizeof. Pole Oproti programovacímu jazyku C, kde lze pro zadání mezí polí využít pouze makro (manifestační konstantu) nebo literál, lze v jazyce C++ použít libovolný celočíselný konstantní výraz. Příklad const int mez = 10; enum { e = 20 #define d = 30; int w[mez], x[e], y[mez+e], z[d+e]; // toto nelze použít v jazyce C double v[d]; // OK v C i C++ Ukazatele V programovacím jazyce C++ nelze přiřadit ukazateli s doménovým typem ukazatel bez doménového typu (void*), např.: void* p; int a, *b; p = &a; // Lze použít v C i C++ b = p; // Chyba v C++ (nutno přetypovat), v C lze použít b = (int*)p; Ukazatel nikam V programovacím jazyce C se pro ukazatel na žádnou platnou adresu používá makro NULL. V programovacím jazyce C++ jej lze sice použít také, ale vzhledem k přísnější typové kontrole mohou nastat situace, kdy se jedná o chybu. Doporučuje se proto v jazyce C++ používat pro ukazatele nikam hodnotu nula (0). Jazyk C++ 1 7

8 Ve vývojovém prostředí Microsoft Visual Studio C++ je dokonce výraz NULL chápan jako synonymum pro 0. Ukazatele lze použít i v místech, kde je očekávána logická hodnota. Dochází k automatické konverzi: 0 => false, jiná hodnota => true. Standardní vstupy a výstupy Výchozím standardním výstupem (stdout) je obrazovka a lze k ní přistupovat zápisem: cout << výraz1 << výraz2 ; Výchozím standardním vstupem (stdin) je klávesnice a lze z ní načítat prostřednictvím zápisu: cin >> proměnná1 >> proměnná2 ; Před použitím cin a cout je potřeba zahrnout do zdrojového souboru hlavičkový soubor <iostream> a zahrnout jmenný prostor std: Příklad: using namespace std; int a, b; cin >> a >> b; cout << Obvod obdélníku je: << 2*(a+b); Reference Reference představuje proměnnou odkazující na jinou proměnnou a deklaruje se pomocí znaku & (ampersand). V programovacím jazyce C nemají reference obdobu. Referenci je nutné v deklaraci inicializovat nějakou l-hodnotou 1 stejného typu jako je deklarovaná reference. Proměnná, na kterou reference odkazuje, se pak nazývá odkazovaná proměnná. Cokoli se pak provede s referencí, bude mít stejný dopad, jako by se to provedlo s odkazovanou proměnnou. Např.: int i; int& refi = i; 1 l-hodnota je výraz označující místo v paměti, kam lze zapisovat. Tedy například proměnná, naopak za l-hodnotu nelze považovat konstantu. Zjednodušeně řečeno lze za l-hodnotu považovat cokoli, co může být na levé straně přiřazení. Jazyk C++ 1 8

9 Provedeme-li nyní přiřazení: refi = 100; Je to naprosto totéž, jako bychom provedli: i = 100; Vezmeme-li v úvahu, že ukazatel ui je ukazatel na int, jsou pak následující dva příkazy naprosto ekvivalentní: ui = &ri; ui = &i; V jazyce C++ nelze deklarovat ukazatel na referenci, pole referencí, referenci na referenci ani proměnnou typu void&. Příklad: int* ui = &i; int*& refui = ui; // OK reference na ukazatel int&* urefi; // chyba ukazatel na reference *ui = 100; *refui = 100; // dělá totéž co *ui = 100; void f(); void (&reff)() = f; // reference na fci void f(); reff(); // volání fce f(); Funkce může vracet referenci. Nejčastěji se reference používají k předávání funkcí odkazem. Konstantní reference Konstantní reference neboli reference na konstantu vznikne, použije-li se v deklaraci reference modifikátor const. Konstantní referenci nelze po inicializaci přiřadit jinou hodnotu. Příklad: int i; const int& refi = i; refi = j; // Chyba, po inicializaci nelze přiřadit jinou hodnotu Inicializátorem konstantní reference může být libovolný výraz. Pouze, pokud se nejedná o l-hodnotu, vytvoří překladač pomocnou proměnnou, do které uloží výsledek tohoto výrazu a reference potom ukazuje právě na tuto pomocnou proměnnou. Příklad: Jazyk C++ 1 9

10 int x = 100; const int& y = 2*x; // y odkazuje na pomocnou proměnnou s hodnotou 200 Implicitní int Pravidlo implicitního integeru, jakožto defaultního typu pro proměnnou či návratovou hodnotu funkce v případě, že v deklaraci není typ uveden, které je známé z programovacího jazyka C, není v normě jazyka C++ povoleno. Funkce V programovacím jazyce C lze provést deklaraci: int f(void); pro funkci bez parametrů a deklaraci: int f(); pro funkci s neznámým počtem a typem parametrů. V jazyce C++ znamenají oba dva výše uvedené zápisy funkci bez parametrů. Zatímco v programovacím jazyce C může volání funkce předcházet její deklaraci, v jazyce C++ tomu tak není. Před voláním funkce v programovacím jazyce C++ musí být uveden alespoň její prototyp (= informativní deklarace funkce). Parametry funkce Stejně jako v jazyce C lze i v jazyce C++ předávat parametry funkce hodnotou: int f(double a); void swap(int* a, int* b); V jazyce C++ lze navíc předávat parametry také odkazem. Parametry, jež jsou předávány odkazem, pak mají formální parametr typu reference. Pokud je formální parametr typu T&, skutečným parametrem musí být l- hodnota typu T. Jestliže je formálním parametrem konstantní reference (const T&), skutečným parametrem pak může být libovolný výraz, který se dá použít k inicializaci proměnné typu T. Nejedná-li se o l-hodnotu typu T, vytvoří překladač pomocnou proměnnou, do níž uloží výsledek výrazu a formální parametr potom bude ukazovat na tuto pomocnou proměnnou. Jazyk C

11 Shrnutí studijního bloku Tento studijní blok seznámil studenta s historickými souvislostmi, aktuálními normami jazyka C++ a s neobjektovými rozdíly mezi programovacími jazyky C a C++. Zejména pak se základními datovými typy, základními příkazy, ukazateli, referencemi a standardními vstupy a výstupy C++ programů. Otázky k procvičení pasáže 1. Jaký je hlavní rozdíl (výhoda) jazyka C++ oproti jazyku C? 2. Vysvětlete pojem deklarace. 3. Vysvětlete pojem definice. 4. Co je standardním vstupem C++ programu? 5. Co je standardním výstupem C++ programu? 6. Jakým způsobem lze přeskočit definici s inicializací v případě skoků goto a switch? Odkazy na další studijní materiály (oficiální stránky Microsoftu pro vývoj v programovacím jazyce C++ v prostředí Micsrosoft Visual Studio) htm?csnumber=50372 (ISO norma C ) Použité zdroje a literatura [1] PRATA, Stephen. Mistrovství v C aktualiz. vyd. Překlad Boris Sokol. Brno: Computer Press, 2007, 1119 s. ISBN [2] Přednášky Ing. Karla Greinera, Ph.D. na předmět Jazyk C++ vyučovaný na Dopravní fakultě Jana Pernera, Univerzity Pardubice. Jazyk C

12 Jazyk C++ 1 Blok 2 Úvod do programovacího jazyka C++ Studijní cíl Ve druhém bloku budou rozebrány další neobjektové rozdíly programovacích jazyků C a C++ a budou představeny a zhodnoceny některé další základní technologie, které se této oblasti dotýkají. Po absolvování bloku bude student ovládat základní pojmy z oblasti programování v jazyce C++ a mít znalosti týkající se neobjektových rozdílů mezi jazyky C a C++. Doba nutná k nastudování 2-3 hodiny Průvodce studiem Pro studium tohoto bloku jsou u studentů požadovány předchozí znalosti z oblasti programování v jazyce C. Pro úspěšné zvládnutí bloku se u studentů předpokládá základní znalost běžných výpočetních prostředků a principů programování (počítač, vývojové prostředí, zdrojový kód, ). Neobjektové rozdíly mezi C a C++ (pokračování) Funkce V programovacím jazyce C lze provést deklaraci: int f(void); pro funkci bez parametrů a deklaraci: int f(); pro funkci s neznámým počtem a typem parametrů. V jazyce C++ znamenají oba dva výše uvedené zápisy funkci bez parametrů. Jazyk C++ 1 1

13 Zatímco v programovacím jazyce C může volání funkce předcházet její deklaraci, v jazyce C++ tomu tak není. Před voláním funkce v programovacím jazyce C++ musí být uveden alespoň její prototyp (= informativní deklarace funkce). Parametry funkce Stejně jako v jazyce C lze i v jazyce C++ předávat parametry funkce hodnotou: int f(double a); void swap(int* a, int* b); V jazyce C++ lze navíc předávat parametry také odkazem. Parametry, jež jsou předávány odkazem, pak mají formální parametr typu reference. Pokud je formální parametr typu T&, skutečným parametrem musí být l- hodnota typu T. Jestliže je formálním parametrem konstantní reference (const T&), skutečným parametrem pak může být libovolný výraz, který se dá použít k inicializaci proměnné typu T. Nejedná-li se o l-hodnotu typu T, vytvoří překladač pomocnou proměnnou, do níž uloží výsledek výrazu a formální parametr potom bude ukazovat na tuto pomocnou proměnnou. Příklad definiční deklarace a volání funkce Swap se dvěma parametry volanými odkazem, která provede výměnu hodnot těchto dvou parametrů: void Swap(int& x, int& y) { int temp = x; x = y; y = temp; int a = 100, b = 200; Swap(a, b); Implicitní hodnoty parametrů funkce Programovací jazyk C++ umožňuje v první definici funkce (definiční deklarace nebo prototyp) definovat výchozí hodnoty jejích parametrů. Nejčastěji bývají implicitní hodnoty parametrů předepsány v prototypech v hlavičkových souborech. Při deklaraci implicitní hodnoty parametru lze vedle konstanty použít i výraz. Pokud se předepíše pro některý parametr výchozí hodnota, je nutné výchozí hodnotu předepsat i pro všechny následující parametry. A pokud se vynechá Jazyk C++ 1 2

14 některý skutečný parametr, musí se též vynechat všechny parametry následující. Příklad: void f(int a, int b = 0, int c = getch()); //použití: x = f(1, 2, 3); //nepoužijí se implicitní hodnoty x = f(1, 2); //impl. hodnota se použije pro c x = f(1); // impl. hodnota se použije pro b a c Referenční funkce Referenční funkcí nazýváme funkci, která vrací referenci. Za příkazem return musí následovat výraz představující l-hodnotu vráceného typu, jež bude následovat také po návratu z funkce (tedy např. globální proměnnou, lokální statickou proměnnou či formální parametr předávaný odkazem). Příklad: const int N = 5; int Pole[5] = {1, 2, 3, 4, 5 int& PrvekPole(int idx) { if(idx < 0 idx >= N) cout << CHYBA! ; else return Pole[idx]; PrvekPole(4) = 20; PrvekPole(5) = PrvekPole(4)*10; Inline (vložené) funkce V programovacím jazyce C++ lze pomocí specifikátoru inline deklarovat tzv. vloženou funkci. Toho se využívá převážně u funkcí s malým tělem, např.: inline int DruhaMocnina(int x) { return x*x; A to hlavně z toho důvodu, že proces volání funkce, předávání parametrů, skoku do funkce a návrat z ní zabere více procesorového času než samotné vykonání těla funkce. Překladač potom na místo volání funkce (např. DruhaMocnina(5)) vloží samotné tělo funkce (např. 5*5). Specifikátor inline však je pro překladač pouze informativního charakteru, není pro něj nikterak závazný. Překladač může takto specifikovanou funkci přeložit také jako obyčejnou a to zejména v těchto případech: v programu je použit ukazatel na tuto funkci, funkce je rekurzivní, jsou v ní použity příkazy, které překladač vyhodnotí jako problémové. Jazyk C++ 1 3

15 Přetěžování funkcí Přetěžování funkcí bývá někdy též označováno jako polymorfismus funkcí a umožňuje požívat více funkcí sdílejících jedno jméno. Prototypy těchto funkcí se vzájemně liší počtem nebo typem předávaných parametrů. Lze tedy např. deklarovat: void f(); //#1 int f(int); //#2 double f(double); //#3 void f(int, double); //#4 Při volání potom překladač vybere tu funkci, jejíž formální parametry nejvíce odpovídají skutečným parametrům v zápisu funkce. Jestliže nastane situace, kdy skutečné parametry neodpovídají přesně formálním parametrům, snaží se překladač vybrat tu, pro kterou je nejsnazší jednoznačná konverze. Příklad: f(); // volá se #1 f(100); // volá se #2 f(100, 8.8); //volá se #4 f( a ); //volá se #2 f(100, 200); //volá se #4 f(0l); // Chyba, složitost převodu long na double nebo // int je stejná, není jednoznačná. Nedostatečné rozdíly k rozlišení přetížených funkcí jsou: typ návratové hodnoty, parametr předávaný hodnotou vs. parametr předávaný odkazem, rozdíl mezi typem T a const T. Dostatečnými rozdíly ještě jsou typy T* a const T* a typy T& a const T&. Výčtové typy Syntaxe: enum jmenovka nep { seznam enumerátorů seznam_deklarátorů nep ; Ke každému identifgikátoru enumerátoru lze přiřadit libovolný celočíselný konstantní výraz. Příklad: enum barvy { cerna = 10, bila = -33, modra = 2*cerna, cervena, ruzova = cervena + bila Zatímco v programovacím jazyce C se musí na výčtový typ odvolávat celým zápisem, tedy: enum barvy b = cerna;, v jazyce C++ postačí jmenovka: Jazyk C++ 1 4

16 barvy b = cerna;. V jazyce C by šlo klíčové slovo enum vynechat v případě, že by se výčtový typ deklaroval pomocí klíčového slova typedef. Zrovna tak by šlo v C++ použít taktéž úplný zápis nebo deklaraci pomocí typedef enum, ale je to zbytečné. Zatímco v jazyce C můžeme do proměnné výčtového typu přiřadit přímo celočíselnou hodnotu, v jazyce C++ tuto musíme přetypovat na příslušný výčtový typ: b = 10; //korektní zápis pouze v C, ne v C++ b = (barvy)10; //Korektní zápis jak v C, tak i v C++ Struktury a unie V programovacím jazyce C++ se řadí struktury i unie mezi objektové typy. V této kapitole budou však prozatím popsány z neobjektového pohledu. Struktura Syntaxe: Příklad: struct jmenovka nep {deklarace_složek seznam_deklarátorů nep ; struct Osoba { char Jmeno[20]; int OsobniCislo; Zatímco v programovacím jazyce C se musí na strukturu odvolávat celým zápisem, tedy: struct Osoba clovek;, v jazyce C++ postačí jmenovka: Osoba clovek;. Unie V programovacím jazyce C++ lze deklarovat anonymní unie, které nejsou v jazyce C k dispozici. Anonymní unie nemá ani deklaraci proměnných ani jmenovku. Ke složce anonymní unie se pak přistupuje pomocí samotného identifikátoru složky. Globální anonymní unie musí být statická; Příklad: int main() { union { int i; unsigned char c[4]; i = 0x ; cout << i << endl; for (int j = 0; j < 4; ++j) Jazyk C++ 1 5

17 cout << (unsigned) c[j] << ' '; system("pause"); return 0; Pole c bude obsahovat tyto hodnoty: c[0] = 0x44 c[1] = 0x33 c[2] = 0x22 c[3] = 0x11 Zarovnání dat v paměti Struktury (i třídy) a veškeré jejich složky jsou v operační paměti zarovnány podle nastavení překladače. Složka struktury začíná ve struktuře na x. bytu. X je spočítáno podle vztahu x = y + z, kde y je byte, na kterém končí předchozí složka struktury a z představuje nejmenší možné číslo takové, aby platil vztah x mod s = 0; s = min{st,da. Ve výše uvedeném vztahu potom mod představuje zbytek po celočíselném dělení, st je velikost datového typu složky a da je zarovnání dat dle nastavení překladače. Pro výpočet x lze použít vzorec x = int(y/s)*s + w, kde w = 0 pokud y mod s = 0, nebo w = s, pokud y mod s > 0. int(x) představuje celou část čísla x. Celá struktura se tak zarovná na a bytů, kde a je definováno jako a = b + c. V tomto vztahu b představuje byte, na kterém končí poslední složka struktury a c je nejmenší číslo takové, aby platl vztah: a mod min{max{st 1, st 2, st n, da = 0. Přičemž st 1, st 2, je velikost datových typů složek struktury. Příklad: struct Struktura { char c; bool b1; int64 i1; bool b2; int16 i2; bool b3; K výše uvedenému příkladu znázorňuje následující tabulka přehled počátečních pozic jednotlivých složek struktury a celkovou velikost struktury pro jednotlivé typy zarovnání dat v paměti. Jazyk C++ 1 6

18 Tabulka 1 - přehled pozic zarovnání dat v paměti Byte, na kterém začíná složka pro da b1 i1 b2 i2 b3 složka Velikost struktury Bitová pole Na rozdíl od jazyka C, kde mohou být složky bitového pole pouze typu int nebo unsigned, mohou v jazyce C++ složky bitového pole být libovolného celočíselného typu, tedy včetně bool či char. Paměťová reprezentace bitových polí závisí na konkrétní implementaci jazyka C++. V implementaci C++ Builder je paměťová reprezentace následující. Složky bitového pole jsou rozděleny po skupinách. Skupina je vždy tvořena po sobě jdoucími složkami stejného datového typu bez ohledu na znaménko. Každá skupina je pak zarovnána podle typu dané skupiny a aktuálního nastavení zarovnání dat v paměti. Celková velikost bitového pole je nakonec zarovnána podle aktuálního nastavení zarovnání dat v paměti. Příklad: struct BitovePole { int s1 : 8; unsigned s2 : 16; unsigned long s3 : 8; long s4 : 16; long s5 : 16; char s6 : 4; Ve výše uvedeném příkladu jsou složky bitového pole rozděleny do tří skupin. První skupinu tvoří složky s1 a s2 a zabírají celkem 24 bitů. V případě zarovnání dat na 1 byte se za tuto skupinu nevloží žádný prázdný bit. V případě zarovnání na 4 byty se za tuto skupinu vloží 8 bitů. Jazyk C++ 1 7

19 Druhá skupina je tvořena složkami s3, s4 a s5. Dohromady tyto složky zabírají 40 bitů. Typ long ovšem zabírá 32 bitů, což vede k tomu, že překladač musí skupinu rozdělit na 2 podskupiny (1. podskupina je složena z s3 a s4 tj. má 24 bitů a 2. podskupina je s5 o velikosti 16 bitů). V případě zarovnání dat na 1 byte se před druhou podskupinu nevloží žádný bit, je-li však zarovnání na 4 byty, před druhou podskupinu se vloží 8 bitů. Třetí skupina je tvořena složkou s6 typu char, který se vždy zarovnává na byte. Nevloží se tedy před tuto složku žádný prázdný bit. Je-li zarovnání dat na 1 byte, vloží se za složku s6 4 prázdné byty. Je-li zarovnání dat na 4 byty, vloží se za s6 12 bitů. Celková velikost bitového pole bude buď 9, nebo na 12 bytů, podle způsobu zarovnání dat na 1 resp. 4 byty. Ukazatele na funkce Ukazatel na funkci lze vytvořit příkazem: ukazatel = &nep identifikátor_fce Příklad: double (*f) (double); //do takto deklarovaného ukazatele lze přiřadit //funkci sin dvěma způsoby f = sin; f &= sin; Rozlišovací operátor Rozlišovací operátor (angl. scope resolution operator) může být jak unární, tak binární. Unární rozlišovací operátor umožňuje přístup k zastíněným globálním identifikátorům. Binární rozlišovací operátor vyznačuje, že identifikátor náleží do daného oboru (jméno objektového typu nebo jmenný prostor). Syntaxe: ::identifikátor obor::identifikátor Příklad: int i = 100; int main(){ Jazyk C++ 1 8

20 int i = 0; cout << lokalni i: << i << endl; cout << globalni << ::I <<endl; Operátory přetypování V jazyce C++ se mimo operátoru přetypování (typ) objevují ještě nové operátory sloužící k přetypování, jsou to: const_cast, static_cast, dynamic_cast, reinterpret_cast. Operátor (typ) V C++ má dva způsoby zápisu. V jazyce C lze použít pouze první způsob. Syntaktický zápis: (typ)výraz_cast název_typu(seznam_výrazů nep ) typ identifikátor typu deklarovaný pomocí typedef, nebo základní konstrukce (např. unsigned int, unsigned int*, ) název_typu jednoslovný název základního datového či výčtového typu, typu deklarovaného pomocí typedef, třídy, struktury, unie. seznam_výrazů jeden či více výrazů (v takovém případě se volá konstruktor objektového typu se jménem název_typu). Příklad: double x = 2.5; int y = (int)x*10; //y bude mít hodnotu 20 int z = int(x*10); //z bude mít hodnotu 25 void* v = &y; // korektní int* uy = (int*)v; //korektní int* uz = int*(v); //chyba, protože int* //není základní název typu Jazyk C++ 1 9

21 Operátory const_cast, dynamic_cast, static_cast a reinterpret_cast Jedná se o operátory rozdělující si funkce operátoru přetypování (typ). Nyní bude uvedena jejich stručná charakteristika, podrobněji se jim věnuje některý z dalších bloků. Syntaxe je společná pro všechny operátory: název_operátoru<označení_typu>(výraz) název_operátoru jeden z operátorů const_cast, dynamic_cast, static_cast nebo reinterpret_cast. označení_typu představuje typ, na který potřebujeme přetypovat. výraz výraz, jehož výsledný typ potřebujeme přetypovat. Přehled const_cast přetypovává výraz přidáním/odebráním modifikátoru const nebo volatile (nestálá instance). Příklad: const int i = 500; int* ui; ui = &i; // Chyba ui = const_cast<int*>(&i); // OK dynamic_cast slouží k přetypování referencí a ukazatelů na objektové typy v rámci dědické hierarchie. Kontroluje se, zda má smysl. static_cast běžné přetypování (např. mezi typy celých a reálných čísel), nekontroluje se, zda má smysl. reinterpret_cast k nestandardnímu přetypování, např. celé číslo na ukazatel. Operátor sizeof Na rozdíl od jazyka C, má tento operátor v jazyce C++ dva způsoby zápisu. V jazyce C je možný pouze první způsob zápisu. sizeof(označení_typu) sizeof unární_výraz Výsledkem je konstanta typu size_t. Při použití na výraz se tento nevyhodnotí, ale určuje se jen jeho výsledný typ, jehož velikost se vrací. Pokud Jazyk C

22 se operátor sizeof použije na referenci, vrací se velikost odkazovaného objektu. unární_výraz např. proměnná, výraz s unárním operátorem, volání funkce. Každý výraz lze převést na unární za použití zápisu do závorek. Příklad: int16 i=10; int16& refi = i; size_t n; n = sizeof i; // n = 2 n = sizeof refi; // n = 2 n = sizeof &i; // n = 4 n = sizeof ++i; // n = 2, i zůstane beze změny n = sizeof sin(1/2); // n = 8, protože sizeof(double) n = sizeof (i*10); // n = 4, protože sizeof(int) n = sizeof (bool); // n = 1 n = sizeof bool; // Error Dynamické proměnné Pro alokaci a uvolnění paměti lze použít v programovacím jazyce C++ stejně jako v programovacím jazyce C funkce malloc, calloc, realloc a free. Ovšem mnohem častěji se využívá operátorů new a delete. New Alokuje prostor paměti pro proměnné. Způsoby syntakticky správného zápisu: new nothrow nep označení_typu new_rozsah nep inicializátor nep new umístění nep označení_typu new_rozsah nep inicializátor nep umístění počáteční adresa alokace označení_typu typ proměnné, která se má alokovat new_rozsah počet prvků alok. pole inicializátor v kulatých závorkách uvedená poč. hodnota proměnné Výsledkem je ukazatel na označení_typu. Příklad: int* a = new int; //*a nemá hodnotu int* b = new int(20); //*b má hodnotu 20 int* c = new int[10] //alokuje pole 10 prvků typu int, //vrací ukazatel na první prvek, //inicializaci prvků pole lze //provést až po alokaci //např. for cyklem Jazyk C

23 //alokace vícerozměrného pole typedef int tradek[10]; //dekl. typu řádek matice tradek* d = new int[5][10];//alokace matice o 5 řádcích //a 10 sloupcích, //inicializaci prvků opět //nutno provést až po alokaci V případě neúspěchu operátoru new dojde k vyvolání výjimky typu bad_alloc. Delete Uvolňuje paměť alokovanou proměnnými. Syntakticky korektní zápis: delete ukazatel delete [] ukazatel ukazatel výraz, jež vrací adresu vrácenou operátorem new. Operátor delete sice uvolní alokovanou paměť, ale hodnotu ukazatele nemění. Operátor delete se nevolá pro proměnnou, která byla alokovaná s umístěním. Příklad: delete a; // dealokace jedoduché prom. a delete [] c; // dealokace pole c Shrnutí studijního bloku Tento studijní blok seznámil studenta s neobjektovými rozdíly mezi programovacími jazyky C a C++. Zejména pak s rozdíly ve funkcích, operátorech a způsobu dynamického alokování a uvolňování paměti. Byly zavedeny termíny pro struktury a unie a s nimi související bitová pole, se kterým byl nastíněn způsob řazení dat v operační paměti za běhu programu. Otázky k procvičení pasáže 1. Jak mohou být předávány parametry funkcí? 2. Co je to implicitní hodnota parametru funkce? 3. Co jsou to inline funkce? 4. Kdy a z jakého důvodu se inline funkce používají? 5. Jakými operátory se dynamicky alokují a dealokují proměnné, jak lze dealokovat pole? Jazyk C

24 Odkazy na další studijní materiály (oficiální stránky Microsoftu pro vývoj v programovacím jazyce C++ v prostředí Micsrosoft Visual Studio) htm?csnumber=50372 (ISO norma C ) Použité zdroje a literatura [1] PRATA, Stephen. Mistrovství v C aktualiz. vyd. Překlad Boris Sokol. Brno: Computer Press, 2007, 1119 s. ISBN [2] Přednášky Ing. Karla Greinera, Ph.D. na předmět Jazyk C++ vyučovaný na Dopravní fakultě Jana Pernera, Univerzity Pardubice. Jazyk C

25 Jazyk C++ 1 Blok 3 Objektové typy jazyka C++ Studijní cíl Ve třetím bloku bude představen a rozebrán nejdůležitější objektový typ jazyka C++ a to sice třída. Po absolvování bloku bude student schopen navrhovat základní třídy v programovacím v jazyce C++. Doba nutná k nastudování 2-3 hodiny Průvodce studiem Pro studium tohoto bloku jsou u studentů požadovány předchozí znalosti z oblasti programování v jazyce C a znalost základů objektově orientovaného programování. Pro úspěšné zvládnutí bloku se u studentů předpokládá základní znalost běžných výpočetních prostředků a principů programování (počítač, vývojové prostředí, zdrojový kód, ). Třída Třída představuje základní pojem z oblasti objektově orientovaného programování. Anglicky class. Ve smyslu objektově orientovaného programování lze za třídy v jazyce C++ považovat jednak třídy, ale jednak také struktury a unie. Tyto objektové datové typy se deklarují pomocí klíčových slov struct (struktura), union (unie) a class (třída). V dalším textu bude pojem třída představovat obecný pojem pro objektový typ. Třída ve smyslu datového typu deklarovaného pomocí klíčového slova class bude vždy upřesněna blíže. Struktury (struct) a třídy deklarované pomocí class jsou si ve své podstatě velice podobné. Hlavní rozdíly jsou v možnostech dědění a ve výchozích přístupových právech. Unie (union) se potom od těchto liší trochu více. Detailněji budou popsány později. Jazyk C++ 1 1

26 Syntakticky korektní zápis pro třídy v jazyce C++ je následující: informativní deklarace: klíč jmenovka; definiční deklarace klíč jmenovka nep { tělo_třídy seznam_deklarátorů nep ; klíč jmenovka: seznam_předků { tělo_třídy seznam_deklarátorů nep ; klíč určuje konkrétní typ třídy (class, struct, union). tělo_třídy představuje specifikace přístupových práv (public, protected, private), deklarace a definice atributů, metod, typů šablon či přátel. Obsahuje tedy seznam deklarací složek (členů) třídy. V angl. literatuře se uvádí výraz class member. Za složky třídy jsou považovány: atributy představující datové složky, metody představující funkční složky (členské funkce), typy představující takzvané vnořené (angl. nested) typy, šablony budou probrány později. Deklarace mohou být v libovolném pořadí a před každou deklarací může být uvedena specifikace přístupových práv. jmenovka představuje identifikátor deklarovaného typu. seznam_deklarátorů deklarátory proměnných tohoto typu, polí, ukazatelů na tento typ, seznam_předků určuje od jakých objektových typů je deklarovaná třída odvozena. Proměnné, které jsou deklarovány objektovým typem (class, union, struct) se nazývají instance. Za objekt je pak považována manipulovatelná oblast paměti proměnná základního typu, objektového typu, pole hodnot, ukazatele na funkci, Lze tedy též říci, že objekt je instance třídy. Deklarace objektových typů mohou být jednak globální, jednak lokální v deklaraci jiné třídy (vzniká tzv. vnořená třída) nebo lokální ve funkci (lokální třída). Jazyk C++ 1 2

27 V deklaraci lze vynechat jmenovku třídy, potom se jedná o takzvanou nepojmenovanou třídu. Pokud se deklaruje nepojmenovaná třída, nesmí být vynechán seznam deklarátorů. Výjimku tvoří anonymní unie a deklarace vnořené třídy. Ke složkám třídy lze přistupovat pomocí operátorů:. (tečka) kvalifikace pro přístup pomocí instance třídy nebo reference na třídu. -> nepřímá kvalifikace pro přístup pomocí ukazatele na třídu. Atributy Deklarace atributu jakožto datových složek třídy je obdobná deklaraci klasických proměnných. Navíc lze u atributů deklarovat některé paměťové třídy (static pro statické atributy a mutable pro měnitelné atributy). Nestatickým atributem třídy TA nemůže být: instance (nebo pole instancí) třídy TA, instance jiné třídy, kde je jako atribut instance (nebo pole instancí) třídy TA, instance třídy, která je odvozena od třídy TA. Může jím však být ukazatel či reference na třídu TA. Příklad: struct TA{ TA A; //Chyba TA &RefA, *UkazA; //OK TB B; //OK, pokud TB není odvozena od TA a/nebo //nemá jako atribut instanci TA. TB &RefB, *UkazB; //OK Metody Funkční složky třídy se deklarují buď informativní deklarací (prototypem) nebo definiční deklarací. V případě, že je uveden pouze prototyp metody, je nezbytné její tělo definovat později. Tělo metody lze definovat i mimo tělo třídy, je pak ovšem nutné její jmenovku uvést jmenovkou třídy a rozlišovacím operátorem. Příklad: void TA::Metoda() { Kde TA představuje jmenovku třídy. Jazyk C++ 1 3

28 Za funkční složku třídy (metodu) jsou též považovány konstruktory, destruktory a přetížené operátory. Funkční složky třídy lze deklarovat též s paměťovou třídou static (vznikají takzvané statické metody). Lze také uvést specifikátory inline, explicit (pouze u konstruktorů) nebo virtual. Pokud má být některá metoda deklarovaná jako vložená (obdoba inline funkce), musí být v těle třídy uvedena kompletní (definiční) deklarace nebo musí být u prototypu uvedeno klíčové slovo inline. Příklad: struct TA { int x, y; int VratSoucet { return x + y; //vložená metoda inline int VratSoucin(); //vložená metoda void Vypis(); //není vložená inline int TA::VratSoucin { //definice vložené metody return x*y; void TA::Vypis() { std::cout << x << << y; Přístupová práva Pomocí specifikátorů public, protected a private lze docílit omezení přístupu různých částí programu ke složkám třídy. Pokud je uvedena specifikace přístupu, platí pro všechny následující deklarace až po nový výskyt specifikace přístupu. public určuje složky třídy, které jsou přístupné všem částem programu bez omezení. Jedná se tedy o veřejné složky. protected označuje chráněné složky, které jsou přístupné pouze metodám této třídy a jejím potomkům a spřáteleným třídám. private složky určené tímto specifikátorem jsou přístupné pouze metodám dané třídy a třídám spřáteleným. Jedná se o soukromé složky. Příklad: class TB { int a; //soukromý atribut int b; //soukromý atribut protected: int c; //chráněný atribut Jazyk C++ 1 4

29 int d; //chráněný atribut int Soucet() { return a + b; //veřejná metoda protected: void Init(); //chráněná metoda This ukazatel Konstantní ukazatel na danou třídu je určen klíčovým slovem this. Například pro třídu TA by se jednalo o ukazatel typu TA* const. Ukazatel this se používá v nestatických metodách třídy, které jej mají jako skrytý parametr. Například pro: TA A; A.Vypis(); Metodu Vypis() lze definovat takto: void TA::Vypis() { std::cout << this->x << << this->y; Lokální proměnné Pokud se deklaruje lokální proměnná v metodě třídy (včetně parametru této metody), může se deklarovat se stejnou jmenovkou, jakou má atribut třídy. V takovém případě pak lokální proměnná zastiňuje atribut třídy. V případě potřeby přistoupit k datové složce třídy, je nutné uvést před jmenovkou atributu identifikátor této třídy a rozlišovací operátor nebo k němu přistoupit přes ukazatel this. Uvažujme příklad, kde struktura TA obsahuje atribut x a metodu SetX: // do atributu x se uloží hodnota parametru x void SetX(int x) { TA::x = x; // opět se do atributu x uloží hodnota parametru x void SetX(int x) { this->x = x; Statické atributy Datové složky třídy, které jsou specifikovány paměťovou třídou static jsou společné pro všechny instance třídy a existují i ve chvíli, kdy žádné instance třídy neexistují. Na statické atributy lze nahlížet jako na globální proměnné v dané třídě, na které se vztahují přístupová práva (private, public, protected). Jazyk C++ 1 5

30 Statické datové složky nemusí být v metodách dané třídy nikterak kvalifikované. Je nutné je však kvalifikovat mimo metody této třídy, a to buď jmenovkou třídy a rozlišovacím operátorem nebo jmenovkou instance třídy a operátorem kvalifikace respektive nepřímé kvalifikace. Deklarace statické datové složky v rámci definice třídy má pouze informativní charakter a nevyhrazuje místo v paměti pro tento atribut. V definiční deklaraci je potřeba jmenovku statického atributu kvalifikovat jmenovkou třídy a rozlišovacím operátorem bez specifikátoru static. Lze jej zde též inicializovat. Statickým atributem nemůže být bitové pole, naopak oproti nestatickým atributům, může statickým atributem třídy TA být: instance (nebo pole instancí) třídy TA, instance jiné třídy, kde je jako atribut instance (nebo pole instancí) třídy TA, instance třídy, která je odvozena od třídy TA. Statické atributy nemohou být součástí lokální třídy a nemohou být zároveň měnitelné (mutable). Pokud je statická datová složka konstantního celočíselného (nebo výčtového) typu (včetně bool a char), může se inicializovat přímo v těle třídy a nemusí být definován mimo tělo třídy. Příklad: class TIntArr { int *a, n; static int PocAlokPrvku; //statický atribut udávající //celkový počet alokovaných //prvků static const int MaxPocPrvku = 1000; // statický //atribut konstantního //celočíselného typu //inicializovaný celočíselným //konstantním výrazem void Alokuj(int _n); void Dealokuj() { PocAlokPrvku -= n; /*... */ void TIntArr::Alokuj(int _n) { if (_n <= MaxPocPrvku) { PocAlokPrvku += n; //... Jazyk C++ 1 6

31 int TIntArr::PocAlokPrvku = 0; // static se před int // neuvádí TIntArr A; //výpis počtu alokovaných prvků dvěma způsoby cout << A.PocAlokPrvku; cout << TIntArr::PocAlokPrvku; Statické metody Funkční složky třídy, které jsou specifikovány paměťovou třídou static jsou společné pro všechny instance třídy a existují i ve chvíli, kdy žádné instance třídy neexistují. Statické metody třídy TA mohou tak přímo využívat pouze statické atributy třídy TA. Nemají tedy ani k dispozici ukazatel this. Statické funkční složky nemusí být v metodách dané třídy nikterak kvalifikované. Je nutné je však kvalifikovat mimo metody této třídy, a to buď jmenovkou třídy a rozlišovacím operátorem nebo jmenovkou instance třídy a operátorem kvalifikace respektive nepřímé kvalifikace. Statickými metodami nemůžou být konstruktory a destruktory, ani virtuální metody. Příklad: class TIntArr { int *a, n; static int PocAlokPrvku; pulic: void Alokuj(int _n) { PocPrvku += _n; /*... */ void Dealokuj() { PocPrvku -= n; /*... */ //statické metody static int DejPocAlokPrvku() { return PocAlokPrvku; static int DejPocAlokBytu(); int TIntArr::PocAlokPrvku = 0; int TIntArr::DejPocAlokBytu() // static se před int //neuvádí { return PocAlokPrvku * sizeof(int); TIntArr A; //výpis počtu alokovaných prvků dvěma způsoby cout << A.PocAlokPrvku; cout << TIntArr::PocAlokPrvku; Jazyk C++ 1 7

32 Konstantní a nestálé instance metody Instance tříd mohou být deklarovány s tzv. cv-modifikátory: modifikátor pro konstantní instanci (const), modifikátor pro nestálou instanci (volatile) nebo modifikátor pro konstantní nestálou instanci (const voaltile). Příklad: //deklarace konstantní instance A třídy TA const TA A; Konstantní instance třídy nemohou měnit její nestatické atributy s výjimkou atributů označených jako měnitelných (mutable). Konstantní instance třídy mohou volat pouze statické a konstantní metody této třídy. Nestálé instance třídy mohou volat pouze statické a nestálé metody této třídy. Pro konstantní nestálé metody platí kombinace obou výše uvedených omezení. Konstantní metoda třídy se deklaruje s modifikátorem const uváděným za kulatou závorkou uzavírající seznam formálních parametrů metody. Příklad: struct TA { //... void Vypis() const; void TA::Vypis() const { /*... */ Obdobným způsobem (užitím modifikátorů volatile a const volatile) se deklarují i nestálé a konstantní nestálé metody. CVmodifikátory jsou součástí deklarace metody, je nutné je tedy uvádět jak v prototypu, tak v definici metody. V jedné třídě lze definovat dvě metody se stejným názvem (identifikátorem) a stejnými parametry, které se liší jen modifikátorem const. Pro konstantní instanci se pak volá konstantní metoda a pro nekonstantní instanci se volá nekonstantní varianta této metody. Pro konstantní a nestálé metody lze volat nekonstantní a nestálé konstruktory, destruktory a statické metody. Ty nelze deklarovat jako konstantní nebo nestálé. Jazyk C++ 1 8

33 Příklad: struct TA { int a; mutable int b; static int x; static void MocninaX() { x *= x; int NasobekA(int n) { return a *= n; int NasobekA(int n) const { return a*n; void Set(int _a, int _b) { a = _a, b = _b; void SoucetA(int n) const { a += n; // Chyba void SoucetB(int n) const { b += n; // OK const TA A = { 10, 20 // konstatní instance, // a = 10, b = 20 TA B; // nekonstatní instance //příklady použití A.a = 100; // Chyba A.b = 30; // OK A.x = 40; // OK - kontantní instance může měnit // statické atributy B.a = 1; // OK A.MocninaX(); // OK - konstantní instance může // volat statické metody A.Set(10, 20); // Chyba B.Set(1, 2); // OK A.NasobekA(10); // OK - volá se konstatní metoda B.NasobekA(10); // OK - volá se nekonstatní metoda void f(ta& c, const TA& d, const TA* e, int a) { c.set(a, a); // OK d.set(a, a); // Chyba e->set(a, a); // Chyba Přátelé třídy Ke všem složkám dané třídy mohou přistupovat i třídy a funkce, které nejsou součástí této třídy. Tyto funkce a třídy musí být tzv. spřátelené funkce (třídy). Syntaktický zápis spřátelených tříd: friend prototyp_funkce; friend definiční_deklarace_funkce; friend klíč identifikátor_objektového_typu; V dané třídě lze definovat prototyp spřátelené funkce nebo celou její definici. Pokud se uvede definice, bude překladač s takovou funkcí zacházet jako s funkcí vloženou. A to bez ohledu na to, zda je či není deklarována s modifikátorem inline. Jazyk C++ 1 9

34 Jestliže je definice funkce uvedena mimo tělo třídy, musí být uvedena modifikátorem inline, pokud chceme, aby byla vložená. Za spřátelenou třídu lze považovat třídu, která má všechny metody deklarované jako spřátelené. Specifikace přístupu může být před deklarací spřátelené metody uvedena, avšak na danou metodu se nevztahuje. Přátelství tříd není ani tranzitivní, ani dědičné. Přátelství se nevztahuje ani na třídy vnořené. Příklad: Pokud je třída TB přítelem třídy TA a třída TC je přítelem třídy TB, neznamená to, že by třída TC byla automaticky přítelem třídy TA. Obdobně, je-li třída TB přítelem třídy TA a třída TD je potomkem třídy TB, neznamená to, že by třída TD byla automaticky přítelem třídy TA. Příklad: class TKomplexCislo { double r, i; void Set(double _r, double _i) { r = _r; i = _i; friend double abs(const TKomplexCislo& t) // vložená // funkce { return sqrt(t.r*t.r + t.i*t.i); friend void FriendSet(TKomplexCislo& t, double r, double i); friend class TKomplexCisloArr; // v metodách třídy TKomplexCisloArr lze přistupovat // ke všem složkám třídy TKomplexCislo friend void TKomplexCisloList::SetAll(double r, double i); // metoda SetAll třídy TKomplexCisloList může // přistupovat ke všem složkám třídy TKomplexCislo void FriendSet(TKomplexCislo& t, double r, double i) { t.r = r; t.i = i; TKomplexCislo kc; kc.set(10, 20); double a = abs(kc); FriendSet(kc, 1, 2); double b = abs(kc); Shrnutí studijního bloku Tento studijní blok seznámil studenta se základními objektovými typy programovacího jazyka C++. S metodami a atributy tříd, ukazatelem this, lokálními, statickými, konstantními a nestálými proměnnými a metodami. Jazyk C

35 Byly zavedeny termíny pro třídy, struktury a unie. Otázky k procvičení pasáže 1. Uveďte, jaké známe cv-modifikátory. 2. Co jsou to statické atributy? 3. Vysvětlete pojem objekt. 4. Jakým klíčovým slovem se deklarují spřátelené funkce? 5. Co znamená, že je nějaká třída spřátelená? Odkazy na další studijní materiály (oficiální stránky Microsoftu pro vývoj v programovacím jazyce C++ v prostředí Micsrosoft Visual Studio) htm?csnumber=50372 (ISO norma C ) Použité zdroje a literatura [1] PRATA, Stephen. Mistrovství v C aktualiz. vyd. Překlad Boris Sokol. Brno: Computer Press, 2007, 1119 s. ISBN [2] Přednášky Ing. Karla Greinera, Ph.D. na předmět Jazyk C++ vyučovaný na Dopravní fakultě Jana Pernera, Univerzity Pardubice. Jazyk C

36 Jazyk C++ 1 Blok 4 Objektové typy jazyka C++ (pokračování) Studijní cíl Ve čtvrtém bloku se pokračuje v probírání objektových typů jazyka C++. Po absolvování bloku bude student obeznámen se všemi základními způsoby vytváření instancí třídy v programovacím jazyce C++ pomocí různých typů konstruktorů. Doba nutná k nastudování 2-3 hodiny Průvodce studiem Pro studium tohoto bloku jsou u studentů požadovány předchozí znalosti z oblasti programování v jazyce C a v jazyce C++ a znalost základů objektově orientovaného programování. Pro úspěšné zvládnutí bloku se u studentů předpokládá základní znalost běžných výpočetních prostředků a principů programování (počítač, vývojové prostředí, zdrojový kód, ). Třída (pokračování) Vnořené typy Programovací jazyk C++ umožňuje v těle jedné třídy deklarovat vnořený typ: pomocí typedef, výčtový typ, objektový typ. Na takto vytvořené vnořené typy se vztahují specifikátory přístupových práv. Pokud je vnořený typ užíván mimo obklopující třídu, je nutné jej klasifikovat buď názvem obklopující třídy a rozlišovacím operátorem nebo případně identifikátorem instance obklopující třídy a jedním z kvalifikačních operátorů. Jazyk C++ 1 1

37 Stejným způsobem je nutné identifikovat také výčtové konstanty vnořených výčtových typů. Příklad: class TOsoba { enum { MaxDelka = 20 private: char Jmeno[MaxDelka]; // zde se MaxDelka // nemusí kvalifikovat //... //mimo třídu je potřeba kvalifikovat char Pole[TOsoba::MaxDelka]; Metody vnořeného objektového typu nemají vzhledem ke složkám obklopující třídy žádné výjimky z pravidel o přístupnosti. A ani opačně nemá obklopující třída žádná privilegia při přístupu ke složkám vnitřní třídy. Pokud má mít třída přístupné chráněné a soukromé složky vnořené třídy, musela by být deklarována jako její přítel. Příklad: class TDList { class TUzel { // deklarace vno!eného typu TData Data; TUzel *Dalsi, *Predch; void SetData(TData& _Data); //... private: TUzel *Prvni, *Posledni; //... void TDList::TUzel::SetData(TData& _Data) { Data = _Data; V obklopující třídě lze vnořený typ deklarovat pouze jejím klíčem (class, struct, union) a jmenovkou. Definovat vnořený typ pak lze i mimo tělo obklopující třídy. V takovém případě je nutné jej potom kvalifikovat jmenovkou obklopující třídy. Příklad: class TDList { Jazyk C++ 1 2

38 class TUzel; // informativní deklarace vnořené třídy private: TUzel *Prvni, *Posledni; //... class TDList::TUzel { // definiční deklarace vnořené // třídy TData Data; TUzel *Dalsi, *Predch; void SetData(TData& _Data); //... void TDList::TUzel::SetData(TData& _Data) { Data = _Data; Inicializace bez konstruktoru Stejně jako v programovacím jazyce C, lze i v programovacím jazyce C++ inicializovat instance třídy stejně jako složky struktury a unie pomocí kulatých závorek. A to v případě, že tento objektový typ: nemá konstruktor, všechny jeho atributy jsou veřejné a nekonstantní, ani jeden z jeho nestatických atributů není reference, nemá předka, nemá virtuální metodu. Pomocí vnitřních složených závorek se deklarují atributy objektových typů a pole hodnot deklarované v rámci třídy. Příklad: class TA { int x[2]; int y; struct TB { int i, j; b; A = { { 1, 2, 3, { 4, 5 // A.x[0] = 1, A.x[1] = 2, A.y = 3, A.b.i = 4, A.b.j = 5 // nemusí se inicializovat všechny hodnoty, v takovém // případě se zbytek inicializuje nulou. TA AA = { { 1, 2, 3 // AA.x[0] = 1, AA.x[1] = 2, AA.y = 3, AA.b.i = 0, // AA.b.j = 0 TA AAA = { // AAA.x[0] = 0, AAA.x[1] = 0, AAA.y = 0, // AAA.b.i = 0, A.b.j = 0 Jazyk C++ 1 3