SeminÃ¡Å C++ - UTEE - VysokÃ© uÄenÃ technickÃ© v BrnÄ

FAKULTA ELEKTROTECHNIKY A KOMUNIKAČNÍCH TECHNOLOGIÍ 

VYSOKÉ UČENÍ TECHNICKÉ V BRNĚ 

Seminář C++ 

Garant předmětu: 

Doc.Ing.Pavel Fiala, Ph.D. 

Autoři textu: 

Doc. Ing. Pavel Fiala, Ph.D. 

Ing. Eva Kroutilová, Ph.D. 

Ing. Jan Mikulka 

Brno 25.2.2009


VUT FEKT v Brně 

Obsah 

1 ÚVOD ................................................................................................................................4 

1.1 ZÁKLADNÍ POJMY A UJEDNÁNÍ.....................................................................................5 

1.2 VLASTNOSTI C/C++ ....................................................................................................6 

1.3 ZÁSADY, SMĚRNICE ANSI...........................................................................................8 

1.4 OBJEKTOVĚ ORIENTOVANÉ PROGRAMOVÁNÍ ...............................................................9 

1.5 PROGRAM- OPERAČNÍ SYSTÉM.....................................................................................9 

1.6 SESTAVENÍ PROGRAMU................................................................................................9 

1.7 ZÁKLADNÍ PRVKY ZÁPISU BLOKOVÉHO SCHÉMATU ...................................................12 

1.8 ALGORITMY...............................................................................................................13 

1.9 KONTROLNÍ OTÁZKY .................................................................................................19 

1.10 ÚKOL.........................................................................................................................19 

2 NĚKTERÉ ROZDÍLY C A C++...................................................................................20 

2.1 KLÍČOVÁ SLOVA C++ ................................................................................................21 

2.2 ÚKOL.........................................................................................................................22 

3 TŘÍDY .............................................................................................................................23 

3.1 DATOVÉ SLOŽKY .......................................................................................................24 

3.2 ČLENSKÉ FUNKCE- METODY ......................................................................................25 

3.3 UKAZATEL THIS ........................................................................................................30 

3.4 AGREGÁTY ................................................................................................................30 

3.5 OBLASTI PLATNOSTI A DOSAŽITELNOSTI IDENTIFIKÁTORŮ ........................................31 

3.6 PROSTORY JMEN ........................................................................................................31 

3.7 PAMĚŤOVÉ TŘÍDY ......................................................................................................32 

3.8 KONTROLNÍ OTÁZKY .................................................................................................33 

3.9 ÚKOLY ......................................................................................................................33 

4 OBJEKTY .......................................................................................................................34 

4.1 PŘIŘAZOVÁNÍ OBJEKTŮ .............................................................................................34 

4.2 PŘEDÁVÁNÍ OBJEKTŮ FUNKCÍM .................................................................................34 

4.3 VRÁCENÍ OBJEKTŮ FUNKCEMI ...................................................................................35 

4.4 ÚKOL.........................................................................................................................36 

5 OPERÁTORY.................................................................................................................37 

5.1 PŘEHLED OPERÁTORŮ................................................................................................37 

5.2 POPIS A UŽITÍ OPERÁTORŮ .........................................................................................39 

5.3 PŘETĚŽOVÁNÍ OPERÁTORŮ ........................................................................................42 

5.4 ÚKOL.........................................................................................................................44 

6 DĚDIČNOST ..................................................................................................................45 

6.1 SYNTAKTICKÝ ZÁPIS..................................................................................................45 

6.2 PŘÍSTUPY V DĚDIČNOSTI............................................................................................46 

6.3 ÚKOL.........................................................................................................................48 

7 POLYMORFISMUS ......................................................................................................49 

7.1 ÚKOL.........................................................................................................................49 

8 PŘETĚŽOVÁNÍ FUNKCÍ ............................................................................................50 

8.1 PŘETĚŽOVÁNÍ KONSTRUKTORŮ .................................................................................50 

str. 2



8.2 ANACHRONISMUS PŘETĚŽOVÁNÍ ...............................................................................52 

8.3 PŘETĚŽOVÁNÍ A NEJEDNOZNAČNOST.........................................................................52 

8.4 ÚKOL.........................................................................................................................53 

9 ŠABLONY FUNKCÍ A TŘÍD .......................................................................................54 

9.1 PARAMETRY ŠABLON.................................................................................................54 

9.2 ŠABLONY FUNKCÍ ......................................................................................................54 

9.3 ŠABLONY OBJEKTOVÝCH TYPŮ..................................................................................55 

9.4 ÚKOL.........................................................................................................................56 

10 OBSLUHA VÝJIMEK...............................................................................................57 

10.1 ÚKOL.........................................................................................................................59 

11 ZÁVĚR ........................................................................................................................60 

11.1 LITERATURA..............................................................................................................60 

str. 3



1 Úvod 

Předmět Seminář C++ je vyučován v letním semestru 2. ročníku bakalářského studia 

VUT v Brně, FEKT a předpokládá úspěšné absolvování kurzů Počítače a programování 1 

a Počítače a programování 2. Volně navazuje na znalosti získané v těchto kurzech a bude 

také využívat prostředí Borland C++ Builder 6.0. 

Kurz si klade za cíl rozšířit základní znalosti jazyka C a doplnit o prvky C++ . Usiluje 

o hlubší poznatky a dovednosti cestou praktických zkušeností, které se získají při sestavování 

zadaných programů a jejich odlaďování. Je volena forma semináře s připravenými 

neřešenými úkoly, při jejichž realizace pod odborným dohledem a vedením si student bude 

dále budovat své programátorské schopnosti. Student se tak velmi efektivně a individuálně 

rozvíjí, může dosáhnout dobrých výsledků a získat návyky vedoucí k samostatnému 

vzdělávání nejen v oblastech tvorby počítačových programů. 

Kurzy Počítače a programování 1 a Počítače a programování 2 byly z velké části 

zaměřeny na koncepci událostmi řízeného programování, jeho úvod a procvičení s prvky API. 

Seminář C++ naopak bude budovat klasicky orientované programování - tvorbu funkcí, 

zařazených do událostmi řízeného programu. Bude dbát na efektivní využití prvků C/C++, pro 

tvorbu krátkých a rychlých programů se všemi výhodami jazyka C++. V čase přiděleném pro 

seminář nelze sice zvládnout problematiku C++ na špičkové úrovni, ale je zde prostor pro 

vybudování základních programátorských návyků a potlačení programátorských zlozvyků. 

V programování platí mnoho základních pravidel, jak se stát programátorem. Mezi tři velmi 

důležité patří: „nejdříve mysli, pak piš“, „programátorem se stáváme podle počtu dobře 

napsaných vlastních (nikoliv opsaných) programů“ a „programátor se pozná podle algoritmu“. 

V kurzu se budeme snažit psát programy nezávislé na platformě, na které se budou 

provozovat. 

Následující text lze označit za osnovu pravidel C++, mnohdy „děravou“. Existuje 

několik přístupů k výuce programování. Jedna cesta je založena na doručení veškerých 

informací na stůl budoucího programátora, kterému stačí už jen začít programovat. Jiná cesta, 

která je dle mého soudu bližší skutečnému životu, je získání pouze základních informací 

o programovacím jazyku s ukázkou základních typů příkladů. Programátor si sám musí najít 

doplňující informace a tak i řešení programované úlohy. Samozřejmostí jsou studentovy 

velmi dobré základny algoritmizace. Cestou druhou se orientuje kurz Seminář C++. 

V textu budeme střídat tato různá písma: 

Times New Roman – zvýraznění částí textů (zejména různé názvy) 

Courier – části zdrojových textů 

Courier – klíčová slova ve zdrojovém textu 

Arial 

– název diskového souboru nebo adresáře 

Arial 

– nově zaváděný termín 

str. 4



1.1 Základní pojmy a ujednání 

Programátoři mezi sebou komunikují specifickým jazykem. Abychom tomuto jazyku 

porozuměli, seznámíme se nyní společně s pojmy, s nimiž se budeme setkávat. 

Abstrakce pojem je převážně používán v souvislosti s implementací tříd. Označuje 

skutečnost, kdy třída je chápána jako vnějšími vlastnostmi popsaný objekt a není dále 

vysvětlena jeho vnitřní funkce. 

Členská funkce je taková, která patří k jedné třídě. Zahrnuje chování objektů této třídy. 

Někdy se mluví o metodě. 

Dědění je označení vztahů v hierarchii objektů a tříd. Třídy lze uspořádat do hierarchie 

a předávat (přebírat)-dědit tak vlastnosti (základních, rodičovských) tříd. Odvozená třída 

přebírá jak datové složky, tak metody. Odvozená třída představuje specializovanější objekt. 

Základní vlastností objektově orientovaného programování (OOP) je možnost zastoupení 

předka dědicem. 

Funkce je část kódu, která definuje odezvu programu na určitou událost. Funkce je 

posloupnost příkazů, které jsou při jejím volání postupně vykonávány. 

Instance je vzor, příklad, případ typu třídy. Někdy se označuje jako objekt. 

Objekt je označení jak reálných typů, tak i objektových typů (instancí). Označení objekt 

se používá i pro oblast paměti, se kterou lze manipulovat (proměnná, konstanta, funkce, atd.) 

Objektově orientovaný je nazýván přístup, při kterém jsou problémy řešeny jako 

zavádění, určování a implementace objektů ve formě tříd a práce s nimi. Jádro práce 

programátora spočívá v implementaci tříd do řešení problému a volání metod 

z implementovaných tříd. Knihovny tříd se dají opakovaně používat, tím se práce zjednoduší 

a OOP se přiblíží k lidskému způsobu uvažování. 

Polymorfismus (mnohotvarost) je vlastnost, která umožňuje, aby jediný název byl 

použit jak pro více souvisejících a technicky odlišných účelů, tak pro rozdílné metody. Uvnitř 

třídy procesů je volba procesu dána typem dat. 

Předefinování je proces, při kterém se mění vlastnosti zděděné funkce v odvozené 

třídě. Důvodem je úprava funkce tak, aby reagovala správně na požadované volání. 

Předefinování je základním klíčem a krokem k realizaci polymorfismu. 

Přetěžování funkcí je pojem, kdy několik funkcí má stejné jméno, které překladač 

vzájemně rozlišuje podle počtu a složení a typů parametrů. Někdy se tento termín používá 

v souvislosti s hierarchií tříd a polymorfismem, ale je přesnější mluvíme-li o předefinování. 

Přetěžování operátorů je schopnost rozšířit operátory o uživatelem definované typy. 

Překladač určuje, kterou operaci chceme provést. 

Rozhraní je prostředek pro výměnu informací mezi funkcemi, třídami, moduly, atd. 

Rozhraní funkce určují její parametry, rozhraní třídy datové složky nebo členské funkce. 

Skrývání informací a implementace je tendence vývoje překladače. Jde o to, aby 

programátor o funkci nemusel vědět příliš mnoho informací, ale mohl ji přesto používat. 

Třída jako datový typ je představitelem skupiny objektů z řešeného problému se 

společnými vlastnostmi a způsobem chování. 

Událost popisuje přesně definovanou situaci nebo akci, na níž má program reagovat. 

Událostí je např. kliknutí na tlačítko v okně (OnClick), stisknutí klávesy na klávesnici 

str. 5



(onKeyDown) či otočení kolečkem mezi tlačítky myši (OnMouseWheel). Pracujeme-li 

v Borland C++ Builder, píšeme tzv. událostmi řízený program. Pro události, na které má náš 

program reagovat, sestavujeme obslužné funkce. Vznik události odpovídající funkci 

automaticky vyvolá. 

Zapouzdření je mechanismus, kdy objekty v programu lze popsat svými vlastnostmi 

(data) a chováním (metoda), je spojen dohromady kód a data v jednom objektu. To lze 

shrnout do třídy, která objekt reprezentuje. Tím se přistupuje k objektu z vnějšku jako 

k souhrnu vlastností a reakcí. 

1.2 Vlastnosti C/C++ 

V dnešní době je jazyk C a C++ považován za jeden ze základních programovacích 

jazyků. Umožňuje velmi jednoduše sestavit program, aplikaci pro graficky orientovaný 

systém, dokáže pracovat s daty, přistupovat k hardwaru, generuje rychlý kompaktní kód, který 

zůstává přenositelný mezi velkou skupinou počítačů. Má vlastnosti vyššího programovacího 

jazyka. 

Při vyvíjení C++ byla zachována kompatibilita s jazykem C, nikoliv striktně. V C++ 

jsou některé konstrukce nepřípustné, i když v C jsou běžné. Vyskytují se i shodné tvary 

konstrukce v obou jazycích, ale jsou odlišně interpretovány. Základním krokem od C k C++ 

bylo zavedení tříd, což otevřelo cestu do světa objektového programování. Úspěch zavedení 

a používání obou jazyků spočíval v tom, že přechod od C k C++ byl snazší díky téměř úplné 

kompatibilitě obou variant jazyka. Další výhodou C++ je jeho použití bez nutného využívání 

objektově orientovaného programování. 

Řekněme si několik slov o koncepci jazyka C. Jazyk C byl navržen pro systémové 

programování v Unixu. Byl pomocným prostředkem pro velmi rychlé a snadné sestavení 

spustitelného kódu. Jeho rysy lze bodově označit 

• malé bohatství prvků 

• velká rychlost programů 

• připravenost pro modulární programování 

• dobrá přenositelnost 

• blízkost k operačnímu systému 

Jazyk C++ postupem času reagoval na změny v hodnotách ve světě programování. 

Strojový čas je levnější, práce a čas programátora dražší. Charakteristika C++ je vyjádřena 

v několika bodech 

• jednoduchý a spolehlivý 

• vysoký stupeň opakovaného použití (modulární stavba) 

• snadná údržba 

• srozumitelný (až intuitivně) 

Požadavek srozumitelnosti a přenositelnosti vedl ke vzniku rozsáhlého množství 

knihovních funkcí, tím se přenositelnost zhoršila. Různí výrobci překladačů přidávali svá 

vylepšení, a tak se vytvořila paleta modifikací jazyka. Bylo nutné situaci vyřešit a vytvořit 

závazný standard. To provedla komise založená v roce 1983 Americkým národním institutem 

pro standardizaci (American National Standard Institute - ANSI), která v roce 1989 přijala 

str. 6



koncept jazyka ANSI. Od ní jej převzala i organizace ISO (International Standards 

Organization). 

Nabízí se otázka, co je to objektově orientované programování Odpověď není snadná. 

Jde především o způsob myšlení, uvažování a organizace vztahů objektů. Pokusíme se tento 

pojem rozvést. Programování lze chápat jako organizování závislostí, vztahů a výkonných 

operací s předpokladem, že budou provedeny za předem dohodnutých podmínek (syntaxe 

jazyka, algoritmus programovaného problému, … ). První programy byly tvořeny nastavením 

přepínačů, později pomocí děrných štítků, pásek - jazyka symbolických instrukcí. Po roce 

1955 se vývoj zaměřil na první překladače jazyka. Začaly se tvořit lineární dlouhé programy 

s často se opakujícími algoritmy. Proto následoval posun směrem ke strukturovanému 

programování – definované struktury, podprogramy s rekurzivním voláním. Díky omezením 

v rozsahu bylo nutné vyvinout kvalitativně lepší přístup než je strukturované programování 

a tím bylo objektově orientované programování (OOP). OOP se inspirovalo dobrými znaky 

strukturovaného programování a doplnilo je novými koncepty. Základním rysem OOP je 

rozložení problému na základní prvky (komponenty) a ty jsou používány jako samostatné 

a nezávislé objekty. Obsahují své vlastní instrukce a data používané uvnitř objektu. Tím se 

sníží složitost celého programu a je možné tvořit rozsáhlejší algoritmy. Charakteristickými 

vlastnostmi OOP je 

• Zapouzdření (encapsulation) 

• Polymorfismus-mnohotvarost (polymorphism) 

• Dědičnost (inheritance). 

Zapouzdření je způsob chování objektu. Kód i data objektu jsou chráněny před zásahem 

z venčí. Při spojení kódu a dat vzniká objekt. Uvnitř objektu jak kód, tak data, funkce mohou 

být neveřejná (private) nebo veřejná (public). Neveřejná data jsou dostupná jen v daném 

objektu nebo jeho části. Pro uživatele se objekt jeví jako proměnná. Pokaždé, když si 

definujeme nový typ objektu, vytváří se nový typ dat. Uveďme příklady na deklaracích tříd. 

Příklad 1 

class BasicClass 

{ int a; // neveřejné vzhledem k BasicClass 

public: 

double add(double x, double y); 

}; 

nebo jiná třída 

Příklad 2 

// veřejné k BasicClass 

class camera 

{ char *vyrobce, *typ; // znaky popsane hodnotami 

int PocetObjektivu, PocetOptickychElementu; 

Boolean digital, zrcadlovka, profi; 

public: 

void zapnout(); 

// způsob chováni 

void manual(); 


void program(); 


void snimek(); 


void vyvolani(); 


void prohlizeni(); // způsob chováni 

void vypnout(); 


}; 

str. 7



Polymorfismus je vlastnost jazyka, překladače, která umožňuje použití stejných názvů 

pro různě účely (objekty, funkce,…). Tam, kde polymorfismus nebyl povolen, hrozilo 

nebezpečí shody názvů interních i uživatelských a následná kolize programu. Polymorfismus 

dovoluje vytvářet standardní rozhraní k příslušným procesům. Někdy se polymorfismem 

označuje přetěžování funkcí a operátorů. Původní význam byl zaveden pro virtuální funkce. 

Ukážeme si jednoduchý příklad deklarace třídy: 

Příklad 3 

class TrA 

{ public: 

void Fce(int); 

}; 

class TrB 

{ public: 

void Fce(char*); 

}; 

void main() 

{ TrA prvni; 

TrB druha; 

prvni.Fce(3); 

druha.Fce("pokus"); 

} 

Dědičnost je proces, ve kterém jeden objekt může získat vlastnosti jiného procesu. 

Přesněji řečeno, může zdědit původní vlastnosti a doplnit je o vlastní, charakteristické pouze 

pro něj. Tato vlastnost OOP podporuje hierarchické uspořádání programu na místo plošného 

nebo lineárního uspořádání, což zkracuje kód a zpřehledňuje jej. 

1.3 Zásady, směrnice ANSI 

Příčinou úspěšného zavedení jazyka C a C++ do počítačového světa bylo vytvoření 

(komisí ANSI) a respektování několika zásad, které lze shrnout do následujících bodů: 

• Důležitý je existující kód, ne existující implementace (v překladači). Kód by měl být 

zachován za cenu změny implementace překladače. 

• Kód napsaný v jazyce C je přenositelný. ANSI kód nabízí programátorům možnost 

přenositelnosti programu v jazyce C ANSI mezi různými operačními systémy. 

• Kód napsaný v C může být nepřenositelný. Existuje možnost vytvořit programový kód, 

který je vázán na určitý hardware a tím není přenositelný na ostatní. 

• Ohlašovat odlišnosti od standardu. Neměla by nastat varianta, kdy překlad jednoho 

textu programu bude na různých překladačích interpretován různě. Pokud ano, musí být 

na tyto odlišnosti od ANSI programátor upozorněn. 

• Standard je dohodou mezi implementátorem a programátorem. Zásada by měla vést 

k respektování jak u výrobce překladače, tak u programátora. 

Nyní máme definovány základní pojmy, stanovena pravidla a můžeme se věnovat 

procvičování jednotlivých částí. Uvedeme si i příklady některých základních rozdílů mezi C, 

C++ a nové směry v C++. 

str. 8



1.4 Objektově orientované programování 

Objektově orientované programování se není pouze rozšíření znalostí C na některé nové 

prvky C++. (použití nového cout



DOS MS Windows 1.0, 2.0, 3.0, 3.1, 95 

Obr.2 Schéma sestavení programů pro platformy 

Obr.3 Schéma toku událostí v systému událostmi řízeném 

Pro korektní vložení vlastního zdrojového programu do existující šablony je několik přístupů. 

Pokusím se vybrané postupy vysvětlit. První, známý z kurzu Počítače a programování 2 je 

vložení zdrojového kódu jako textu přímo do vygenerované „šablony“. Pak se program 

přeloží a je spustitelný. Tato metoda je poněkud nepružná a „nemotorná“. Musíme mít editor 

textu, správný formát atd. 

str. 10



Příklad 4 

#pragma hdrstop 

#include "Unit1.h" 

//------------------------------------------------------------------ 

#pragma package(smart_init) 

#pragma resource "*.dfm" 

TForm1 *Form1; 

//------------------------------------------------------------------ 

__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner) 

{} 

int mojeExtFunkce(void) 

{/* text vlozene funkce*/} 

//------------------------------------------------------------------ 

void __fastcall TForm1::fPokus(TObject *Sender) 

{} 

//------------------------------------------------------------------ 

Účelnější, ale možná ne tak „vizuálně “ podporované řešení, je vložení textu naší funkce 

pomocí hlavičkového souboru. Neobsahuje-li funkce složité vazby na API a objekty 

uživatelského rozhraní, je to velmi rychlý způsob. K psaní programu nepotřebuji žádný 

složitý programový nástroj. Stačí tužka, papír a na počítači dostupný textový editor. Text by 

vypadal si takto: 

Příklad 5 

#pragma hdrstop 

#include "Unit1.h" 

#include "mojeExtFunkce.h" 

//------------------------------------------------------------------ 

#pragma package(smart_init) 

#pragma resource "*.dfm" 

TForm1 *Form1; 

//------------------------------------------------------------------ 

__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner) 

{} 

//------------------------------------------------------------------ 

void __fastcall TForm1::fPokus(TObject *Sender) 

{} 

//------------------------------------------------------------------ 

Soubor mojeExtFunkce.h v adresáři, kde jsou umístěny soubory projektu má tento obsah 

int mojeExtFunkce(void) 

{ 

/* text vložené funkce*/ 

} 

Pro úplnost ještě snad chybí uvést schéma sestavování programu v současných překladačích. 

Na obr.4 je to velmi zjednodušeně naznačeno. Některé typy souborů nemusí být použity, 

tvůrci překladačů vytvářejí jiné soubory, dočasné soubory jsou mazány. Postup překladu je 

v zásadě zachován, směřuje odshora dolů. 

str. 11



Soubory na disku 

Uživatelské soubory 

Systémové soubory 

*.h *.c *.h 

Předzpracování, kontrola chyb 

*.i 

Překlad, kontrola chyb 

*.dll 

*.obj 

*.obj *.obj *.lib 

*.lib 

*.dll 

Sestavení 

*.exe 

*.com 

*.exe 

DDE 

Obr.4 Postup sestavení spustitelného souboru 

1.7 Základní prvky zápisu blokového schématu 

Pro srozumitelný zápis algoritmů programů si uvedeme základní značky objevující 

v blokových schématech. 

Značka pro začátek, konec 

začátek, 

konec 

Značka pro načtení (vstup), výstup 

Vstup A, Výstup A 

Značka pro skok 

Značka pro předepsaný postup: 

skok na 

A=B, A=A+1, A=A*B 

Značka pro funkci, podprogram 

Značka pro cyklus 

cyklus I = 1, .., N 

Značka pro rozhodnutí 

a, nebo ∧ , ∨ negace A A AB, A=B, A≠B, A≥B, A≤B 

str. 12



1.8 Algoritmy 

Při řešení programátorské úlohy se naskytne zpravidla více přístupů a postupů. Jeden 

postup je z nich třeba vybrat a formulovat jej pomocí vývojového diagramu. Pro výběr se 

musí stanovit vhodná kritéria, aby bylo možné rozhodnout, který postup je „lepší“ a který 

„horší“. Co to je „lepší“ a „horší“ Kritéria pro posuzování kvality algoritmu jsou subjektivní 

a objektivní. Problematika kritérií je velmi rozsáhlá, ale pro účely tohoto textu se budeme 

držet nutných pojmů a praktických důsledků bez uvedení odvození a důkazů a budeme se 

zabývat především základní objektivními kritérii hodnocení algoritmu, která jsou: 

1. rychlost algoritmu (výpočtu) 

2. paměťová náročnost – operační i externí paměť 

3. stabilita algoritmu 

První dvě uvedená kritéria jsou významná hlediska posouzení algoritmů a velmi často 

stojí při hodnocení proti sobě. Algoritmy bývají takové, že jeden z nich je pomalejší, ale 

využívá malou operační paměť, zatímco druhý je rychlejší, ale má vysoké nároky na paměť. 

Často je to způsobeno tím, že pro zrychlení algoritmu je použita další pomocná proměnná 

nebo množina proměnných. Ty jsou uchovány v operační paměti a zvětšují nároky na paměť 

za cenu zrychlení výpočtu. Pro volbu paměťové náročnosti a rychlosti neexistuje obecné 

řešení. Vždy záleží na požadavcích, které jsou kladeny na program. Samozřejmě první dvě 

kritéria jsou závislá i na použitém technickém vybavení (hardwaru). Jako příklad lze uvést 

úlohu vyhledání telefonního čísla v seznamu. Jedním z postupů je tzv. sekvenční vyhledávání. 

Začneme procházet seznam od začátku až do nalezení hledaného čísla. Ve skutečnosti jsou 

jména v seznamu seřazena podle abecedy. Postup při vyhledávání je podle srovnání 

rostoucích n-tic písmen jména. Např. pokud hledáme jméno Novák, první n-tice je N, dále je 

hledána druhá n-tice No, atd. 

Stabilita algoritmu závisí jak na vstupních údajích programu, tak na zvolené metodě 

algoritmu. Doba výpočtu i paměťové nároky bývají také závislé na vstupních údajích. 

Program většinou řeší celou řadu podobných problémů, které se liší právě zadávanými 

vstupními údaji. Trvání výpočtu i paměťové nároky však často neovlivňují konkrétní zadané 

hodnoty, jen velikost vstupních dat. Prakticky je jedno, zda vyhledávám jedno telefonní číslo 

v telefonním seznamu s 3000 položkami nebo vyhledávám naměřenou teplotu s 3000 údaji. Je 

ale rozdíl, pokud vyhledávám telefonní číslo v seznamu Znojma a Brna. Potom bude 

algoritmus mít rozdílnou dobu trvání. 

Paměťová náročnost u algoritmů se uvádí v jednotkách jakými jsou bit nebo bajt. Bit je 

jednotka, která může být buď ve stavu logické jednotky nebo ve stavu logické nuly. Bajt je 

jednotka (slovo), která je složena z několika bitů. Počet bitů v bajtu je dán mnoha kritérii. 

Jsou obvykle používány 8, 16, (24), 32, 64, 128, … bitová slova. 

Časová náročnost se udává v souvislosti s použitým typem procesoru, velikostí RAM 

a její rychlosti, konfiguraci základní desky, typem a výrobcem operačního systému. Udává se 

buď jako doba pro nejhorší případ složitosti algoritmu se vstupními daty velikosti N nebo jako 

průměrný případ výpočtu z N vstupních dat. 

Algoritmy se porovnávají v jejich časové náročnosti a je rozhodnuto, který z nich je 

rychlejší. Stává se, že vstupní data a jejich rozsah nejsou specifikovány. Potom nelze stanovit 

časovou náročnost. Postupuje se tak, že se zvolí pro rozsah dat velké číslo N a provede se 

srovnání algoritmů s uvedením podmínek. Jde o asymptotickou časovou náročnost, tj. časová 

náročnost lepšího algoritmu roste pomaleji s rostoucími hodnotami N. Časovou náročnost lze 

popsat typem funkce a jejím řádem. Rozeznáváme základní, polynomiální a exponenciální 

funkce. Následuje ukázka zadání a vypracování algoritmů základních až triviálních úloh. 

str. 13



Úloha 1 Sestavte a nakreslete diagram algoritmu pro nalezení minimálního čísla z řady N 

zadaných. Nechť je výsledek zobrazen na výstupním zařízení. 

Začátek 

čti N 

A=1e99 

I=1,..,N 

čti číslo X 

vypiš MinimumA 

- 

X



Úloha 3. Sestavte a nakreslete diagram algoritmu pro nalezení součtu čísel z množiny A 

a množiny B . Prvky množiny A i B jsou celá čísla, počet prvků množiny A je N a množiny B 

je M. Nechť je výsledek zobrazen na výstupním zařízení. 

Začátek 

čti N, M 

celá A(N), celá B(M) 

A(1)= .., A(N)=… 

B(1)= .., B(M)=… 

SOUCET=0 

J=1,..,M 

- 

B(J) ≠0 

+ 

SOUCET= SOUCET+B(J) 

- 

I=1,..,N 

A(I)≠0 

+ 

vypiš Součet prvků 

množinyA a B, 

SOUCET 

Konec 

SOUCET= SOUCET+A(I) 

Úloha 4 Sestavte a nakreslete diagram algoritmu pro nalezení součinu čísel z množiny A 

a množiny B . Prvky množiny A i B jsou reálná čísla, počet prvků množiny A je N a množiny 

B je M. Platí, že M=N. Nechť je výsledek zobrazen na výstupním zařízení. 

Začátek 

čti N, M 

reálná A(N), reálná B(M) 

A(1)= .., A(N)=… 

B(1)= .., B(M)=… 

SOUCIN=1 

M≠N 

+ 

Konec 

- 

J=1,..,M 

vypiš Součin prvků 

množinyA a B, 

SOUCIN 

B(J) ≠0 ∧ 

A(J) ≠0 

+ 

- 

SOUCIN A a B je 

roven 0 

SOUCIN= SOUCIN+A(J)*B(J) 

str. 15



Úloha 5 Sestavte a nakreslete diagram algoritmu pro porovnání obsahu množiny A a množiny 

B . Prvky množiny A i B jsou celá čísla, počet prvků množiny A je N a množiny B je M. Pokud 

množiny mají společný prvek (číslo) zobrazte je na výstupním zařízení. 

Začátek 

čti N, M 

X=N 

celá A(N), celá B(M), celá C(X) 

A(1)= .., A(N)=…B(1)= .., B(M)=… 

Spolecna=0, K=0 

- 

M>N 

+ 

X=M 

I=1,..,N 

J=1,..,M 

Spolecna = 0 

- 

+ 

- 

B(J)=A(I) 

+ 

Počet společných prvků K 

Společné prvky C(1,..,K) 

K=K+1 

C(K)= A(I) 

Spolecna=1 

Konec 

Úloha 6 Sestavte a nakreslete diagram algoritmu pro průnik C obsahu množiny A a množiny 

B . Prvky množiny A i B jsou reálná čísla, počet prvků množiny A je N a množiny B je M. 

Množinu C zobrazte na výstupním zařízení. 

Začátek 

čti N, M 

X=N 

reálná A(N), reálná B(M), reálná C(X) 

A(1)= .., A(N)=…B(1)= .., B(M)=… 

Prunik=0, K=0 

- 

M>N 

+ 

X=M 

I=1,..,N 

J=1,..,M 

Prunik = 0 

- 

+ 

- 

B(J)=A(I) 

+ 

Počet společných prvků K 

C(1,..,K) 

K=K+1 

C(K)= A(I) 

Prunik=1 

Konec 

str. 16



Úloha 7 Sestavte a nakreslete diagram algoritmu pro sjednocení C obsahu množiny A 

a množiny B. Prvky množiny A i B jsou reálná čísla, počet prvků množiny A je N a množiny B 

je M. Množinu C zobrazte na výstupním zařízení. 

Začátek 

čti N, M 

reálná A(N), reálná B(M), reálná C(M+N) 

A(1)= .., A(N)=…B(1)= .., B(M)=… 

Reálná Pomocna=0, celá L=0 

I=1,..,N 

J=1,..,M 

Počet prvků L 

C(1,..,L) 

- 

B(J)≠A(I) 

+ 

Konec 

Pomocna= A(I) 

L=L+1 

C(L)=Pomocna 

K=1,..,M+N 

+ - 

C(K)=Pomocna 

Úloha 8 Sestavte a nakreslete diagram algoritmu pro zjištění, zda zadané číslo N je prvočíslo. 

Začátek 

Začátek 

čti N 

Prvocislo= 1 reálné A, reálné B 

I=2,..,celé(√N) 

+ 

Prvocislo=1 

A=celé(N/I) 

B=N/I 

- 

- 

+ 

A=B 

Prvocislo= 0 N není prvočíslo 

N je prvočíslo 

Konec 

čti N, M 

reálná A(N), reálná B(M), reálná C(M+N) 

A(1)= .., A(N)=…B(1)= .., B(M)=… 

Reálná Pomocna=0, celá L=0 

- 

I=1,..,N 

J=1,..,M 

B(J)≠A(I) 

L=L+1 

C(L)=Pomocna 

+ 

Pomocna= A(I) 

K=1,..,M+N 

Počet prvků L 

C(1,..,L) 

+ - 

C(K)=Pomocna 

Konec 

str. 17



Úloha 9 Sestavte a nakreslete diagram algoritmu pro výpočet funkce 5 555 . 

Začátek 

reálná A(40), reálná D 

A(1)=1.0 

I=1,..,555 

D=0.0 

J=1,..,39 

I=39,..,1 

Výpis A(I) 

A(J)= 5*A(J)+D 

D=celé číslo (A(J)/10 10 ) 

A(J)=A(J)-D*10 10 

Konec 

Úloha 10 Sestavte a nakreslete diagram algoritmu pro součet matic A a B. Prvky množiny A i 

B jsou reálná čísla, počet prvků množiny A je N×N a množiny B je M×M. Množinu C zobrazte 

na výstupním zařízení. 

Začátek 

čti N, M 

reálná A(M,N), reálná B(M,N), reálná C(M,N) 

A(1,1)= .., A(1,N)=…B(1,1)= .., B(1,N)=… 

C(1,..,M,1,..,N)=0.0 

I=1,..,N 

J=1,..,M 

Výstup matice C(M,M) 

C(I,J)= C(I,J)+A(I,J)+B(I,J) 

Konec 

Úloha 11 Sestavte a nakreslete diagram algoritmu pro součin matice A a vektoru B. Prvky 

množiny A i B jsou reálná čísla, počet prvků množiny A je N×N a množiny B je M. Množinu C 

zobrazte na výstupním zařízení. 

Začátek 

čti N, M 

reálná A(M,N), reálná B(N), reálná C(N) 

A(1,1)= .., A(1,N)=…B(1)= .., B(M)=… 

C(1,..,N)=0.0 

J=1,..,N 

I=1,..,M 

C(J)= C(J)+A(I,J)*B(I) 

Výstup sloupcové matice 

C(M) 

Konec 

str. 18



Úloha 12 Sestavte a nakreslete diagram algoritmu pro součin matic A a B. Prvky množiny A i 

B jsou reálná čísla, počet prvků množiny A je N×N a množiny B je M×M. Množinu C zobrazte 

na výstupním zařízení. 

Začátek 

čti N, M 

reálná A(M,N), reálná B(N,M), reálná C(N,N) 

A(1,1)= .., A(M,N)=…B(1,1)= .., B(N,M)=… 

C(1,..,N, 1,..,N)=0.0 

K=1,..,N 

I=1,..,N 

J=1,..,M 

Výstup matice C(N,N) 

C(I,K)= C(I,K)+A(J,I)*B(K,J) 

Konec 

1.9 Kontrolní otázky 

1. Vysvětlete, co je to abstrakce a jak se využívá 

2. Vysvětlete, co je to polymorfismus a kde se s ním setkáme 

3. Vysvětlete, co je to přetěžování funkcí a operátorů, jak ovlivní naše možnosti při 

programování 

4. Jak byste charakterizovali vlastnosti jazyka C++ 

5. Jaké jsou základní vlastnosti a rysy objektově orientovaného programování 

6. Pro uvedené příklady algoritmů napište v C++ jednoduché funkce. 

1.10 Úkol 

1. Sestavte jednoduchou funkci, odlaďte ji a spojte s jednoduchým programem v Borland 

Builderu. 

str. 19



2 Některé rozdíly C a C++ 

Mezi jazyky C a C++ i přes jejich podobnost existují drobné rozdíly. Předpokládejme, 

že čtenář má základní znalosti z programování v C a orientuje se v problematice. Pokusím se 

pomocí tabulky ukázat některé rozdíly v obou jazycích. 

OBSAH C C++ VÝZNAM 

prototyp funkce Fce() int Fce(void) 

prototyp funkce 

Fce() 

prototyp funkce nepovinný povinný 

deklarace funkce 

s návratem hodnoty 

deklarace lokálních 

proměnných 

typ proměnné 

nemusí vracet (nebo vrací 

int) 

začátek bloku před 

výkonnými proměnnými 

musí vrátit vždy 

kdekoliv 

bool, klíčová slova 

true, false 

int Fce() 

int Fce(void) 

Pro úplnost a upřesnění vysvětlíme některé často používané pojmy, které se mohou 

nesprávně interpretovat. Mezi první dva patří deklarace a definice. 

Deklarace seznamuje počítač s názvem proměnné, funkce, třídy šablony nebo datového typu. 

Deklarací stanovíme její typ, paměťovou třídu a viditelnost jejího identifikátoru. Určíme také 

typ vracené hodnoty a počet, pořadí a typy parametrů a eventuálně jejich implicitní hodnoty. 

Deklarace v C++ začíná klíčovým slovem extern.a neobsahuje inicializaci. Popis statické 

datové složky v deklaraci třídy je jen deklarace, nikoliv definice. Mezi deklarace patří 

typedef, using. 

Definice nejen objekt popisuje, ale přikazuje i překladači jeho zřízení. Proměnné, funkce 

a další součásti programu dostupné v celém těle programu mohou mít více deklarací. Statické 

proměnné a funkce mohou mít v kterémkoliv z modulů jinou definici. Definice proměnné 

v C++ buď neobsahuje klíčové slovo extern nebo obsahuje inicializaci. Definice funkce 

obsahuje její tělo. Statické datové složky tříd musíme definovat za deklarací třídy (mimo tělo 

funkce). 

Ukážeme si rozdíl mezi deklarací a definicí na jednoduchém příkladě, který provede součet 

dvou celých čísel 

Příklad 6 

int secti(int a, int b); 

// deklarace funkce 

int secti(int a, int b) 

// definice funkce 

{ return(a+b);} // závorky zde nemusí být 

void main(void) 

{ int vysledek = secti(5,10); // volání fce 

str. 20



printf("Soucet je %d.",vysledek); 

} 

Z kurzů Počítače a programování 1 a Počítače a programování 2 jsou známy základní 

informace o datových typech, výčtových typech, jedno a vícerozměrných polích, řetězcích, 

strukturách, bitových polích, uniích, ukazatelích, dynamických proměnných, práci s ukazateli. 

Pokračovali bychom dále v prohloubení znalostí z oblasti tříd. 

2.1 Klíčová slova C++ 

NÁZEV VÝZNAM POZNÁMKA 

asm 

auto 

bool 

break 

case 

catch 

char 

class 

const 

const_cast 

continue 

default 

delete 

do 

double 

dynamic_cast 

else 

enum 

explicit 

extern 

false 

float 

for 

friend 

goto 

if 

inline 

int 

long 

mutable 

namespace 

new 

operator 

private 

protected 

public 

register 

reinterpret_cast 

str. 21



return 

short 

NÁZEV VÝZNAM POZNÁMKA 

signed 

sizeof 

static 

satic_cast 

struct 

switch 

teplate 

this 

throw 

true 

try 

typedef 

typeid 

typename 

union 

unsigne 

using 

virtual 

void 

volatile 

wchar_t 

while 

2.2 Úkol 

1. Sestavte jednoduchou funkci, vyzkoušejte změny mezi syntaxí C a C++, odlaďte ji 

a spojte s jednoduchým programem v Borland Builderu. 

str. 22



3 Třídy 

Třídy slouží ke spojení (zapouzdření) dat a funkcí do jednoho (nového) typu. Umožňují 

předepisovat různá oprávnění k přístupu k jednotlivým prvkům. Třídy mají díky dědičnosti 

hierarchické uspořádání. Deklarace může být zapsána: 

klíč třída[:seznam_předků] 

{ 

deklarace_prvků 

}[případ1,případ2,...]; 

kde je klíč class, struct nebo union, v C++ struktury a unie představují pouze zvláštní 

případy tříd, Třída - identifikátor třídy, :seznam_předků - seznam identifikátorů tříd, 

jejichž vlastnosti má nová třída zdědit, deklarace_prvků - v těle třídy se deklarují její 

složky. Přístup k prvkům mohou upravovat specifikátory přístupových práv (public, 

protected, private). případ1 - zde se mohou definovat případy (instance), 

ukazatele na případy, pole případů. Uveďme si konkrétní příklad. 

Příklad 7 

class Priklad 

{ int Hodnota; // soukromé (private) 

public: 

// veřejné (public) 

Priklad(){Hodnota=1;}; // konstruktor 

protected: 

// chráněné (protected) 

int treti(){ return Hodnota;}; 

private: 

// soukromé (private) 

int Posledni(); 

}; 

• Specifikace přístupových práv platí pro všechny složky, které jsou zapsány za ní, až do 

další specifikace. 

• Specifikace přístupových práv se mohou v deklaraci třídy vyskytovat vícekrát. 

• Složky třídy na začátku deklarace před první specifikací přístupových práv jsou 

automaticky považovány za 

⋅ soukromé (private) ve třídách definovaných pomocí klíčového slova class. 

⋅ veřejné (public) ve třídách definovaných jako struct a union. 

• Specifikace přístupových práv se nevztahují na spřátelené funkce. 

• Používání tříd v OOP se řídí jistými pravidly. Rozlišují se vlastnosti a způsob chování 

objektů. Společné objekty lze zahrnout do jedné třídy. Například: 

Příklad 8 

class Mesto 

{ /* znaky popsané hodnotami*/ 

char *Nazev; 

int PocetObyvatel; 

boolean MestskaDoprava, Silnice, Dalnice, Metro, Letiste, 

Divadlo, park, Obchod, Skola; 

public: /*způsob chování*/ 

str. 23



}; 

void Ubytovani(); 

void Zamestnani(); 

void Odpocinek(); 

void Sport(); 

void Doprava(); 

Pokud podle dané třídy deklarujeme proměnnou – případ (instance), musí být datovým 

složkám přidělena hodnota. Potom deklarovaná proměnná představuje jediné identické město 

např. Brno. 

Mluvili jsme o zapouzdření dat a členských funkcí. Pro práci s třídami se může ještě 

přidat další pojem - skrývání dat. Je to stav, kdy programátor používá členské funkce třídy 

a nestará se, jak program vykoná zamýšlené operace na připojeném HW. Například v třídě 

Mesto pro případ Brno bychom spustili funkci Brno.Doprava(); a tím by program podle 

těla funkce řídil dopravu v celém městě Brně. Programátora ale nezatěžuje, jak se přes 

rozhraní počítače provádí spouštění systémů pro řízení křižovatek, tramvajové a autobusové 

dopravy. 

Dalším pojmem je uzavřenost. Tím se myslí takové nadefinování třídy, které je úplné 

(neobsahuje zbytečně mnoho nebo málo údajů) a je právě vhodná k provádění operací podle 

jejího chování. 

3.1 Datové složky 

Třídy mají datové složky. Každý případ třídy dostane k dispozici paměť pro datové 

složky. Při jejich tvorbě dojde k jejich inicializaci (přiřazením hodnot), které provede 

konstruktor. Se zánikem proměnné datové složky zanikají, což provádí destruktor. 

Datové složky mohou být deklarovány jako: 

• veřejně přístupné (public) 

• chráněné (protected) 

• soukromé (private) 

• statické (static) 

Statické složky 

⋅ 

⋅ 

⋅ 

⋅ 

⋅ 

⋅ 

⋅ 

jsou společné pro všechny případy (instance) 

vznikají při spuštění programu- jde o globální proměnnou, zapsanou ve třídě 

nemohou být deklarovány jako auto, register, extern 

jejich zápis v definici třídy je jen deklarace 

definice se provede vně třídy 

se mohou používat prostřednictvím jména třídy (JmenoTridy::StatickyPrvek) 

nelze je deklarovat pomocí const 

Složky deklarované jako 

⋅ 

⋅ 

⋅ 

const - musí se inicializovat, ale pak je dále nelze měnit (konstanty) 

mutable - lze je měnit i když je případ deklarován jako const 

volatile - ty mohou neočekávaně (asynchronně) měnit svůj obsah, překladač 

neoptimalizuje (zkracuje, upravuje) operace s touto proměnnou 

str. 24



Třída nemůže obsahovat jako datovou složku sebe sama. Ale může obsahovat ukazatel nebo 

reference na nedefinovanou třídu (i na sebe sama). 

Příklad 9 

class test 

{ int PocetObyvatel; 

class test a; 

class test* b; 

class test &c; 

}; 

//Chyba 

//Dobře 

//Dobře 

Lokální třídy 

Třídy, které jsou definovány v příkazové části funkce, se označují jako lokální. Jsou 

omezeny a všechny metody se musí definovat v těle třídy. 

Vnořené třídy 

Příklad 10 

Uvnitř třídy se může jako složka deklarovat datový typ. Tedy i třídu. 

int i; 

class Vnejsi 

{ static int n; 

public: 

int i; 

static float f; 

class vnitrni 

{ 

void test(Vnejsi &glob) 

{ 

i=5; 

// Má být glob.i 

f=1; 

// Správně 

::i=1; 

// Odkaz na globální i 

glob.i=-1; // Správně, i z třídy global 

n=5; 

// Chyba 

}; 

}; 

}; 

class priklad* b; 

class priklad &c; 

//Dobře 

//Dobře 

3.2 Členské funkce- metody 

• Mohou být deklarovány jako public, protected, private. 

• Pokud jsou definované jako static, pak pracují pouze s datovými složkami static. 

str. 25



• Metody mohou pracovat s objekty typu const. Metody mohou být deklarovány jako 

virtual, inline (ukázkou jednoduché inline funkce, která zjistí, zda 10 je sudé 

číslo je Příklad 11). 

• Mohou být přetěžovány pouze členskými funkcemi stejné třídy. 

• Mají přístup ke všem prvkům své třídy bez ohledu na přístupová práva. 

• Jsou jediným prostředkem s funkcemi typu friend, jak získat přístup k soukromým 

prvkům- private. 

• Metody mohou být deklarovány jak uvnitř, tak vně deklarace třídy. 

Příklad 11 

#include 

using namespace std; 

inline int funkce1(int x) { return !(x%2);} // vrací true, je-li 

// argument funkce sudý 

int main() 

{ if(funkce1 (10)) cout



Přístup k prvkům tříd 

Velmi osvědčené je navržení tříd tak, že jejich prvky jsou typu private. Potom je mohou 

používat jen metody dané třídy. Vně třídy k nim mají přístup pouze členské funkce. 

Přístup zevnitř třídy 

Příklad 14 

class test 

{ private: 

int n1, n2; 

int fun1() {return n1*n2;} 

public: 

void fun2(int j) 

{ 

n1=j+1; 

n2=fun1(); 

} 

}; 

test z; 

// z je případem třídy test 

z.fun2(222); 

// Změna z.n1 a z.n2 

Přístup z vnějšku třídy 

Pokud se pracuje s prvky třídy a přistupuje se k nim z vnějšku třídy, musí se uvést případ, pro 

který chceme složky měnit. Přístup je pomocí případu třídy a operátoru tečka- jméno složky 

nebo ukazatel a připojíme jméno složky pomocí operátoru přiřazení (->). 

• Přístup přes případ je filtrován specifikátory public, protected, private. 

Příklad 15 

class test 

{ int n1; // Private (soukromé) 

int fun1(); 

// Private (soukromé) 

public: 

int n2; 

// Public (veřejné) 

int fun2(); 

// Public (veřejné) 

}; 

void main() 

{ test z, *PokusD; //Případy třídy 

int i; 

i=z.n1; 

//Chyba,n1 je private-nelze přistoupit zvenčí 

i=PokusD->fun1(); //Chyba,fun1 je private–nelze přistoupit zvenčí 

i=z.n2; 

// Správně, n2 je public 

i=PokusD->fun2(); // Správně, fun2 je public 

return 0; 

} 

• Pravidla přístupu se obejdou přes přátele - klíčové slovo friend. Zápis je 

friend ProtoypFunkce; 

friend class JmenoTridy; 

str. 27



Aby se tyto přístupy podařilo provést, musí být funkci předán ukazatel na případ, reference na 

případ nebo přímo případ třídy. 

Příklad 16 

class test 

{ int n1; 

friend void fun1(test&); 

}; 

void fun1(test& objekt) 

{ int a; 

a=objekt.n1; 

} 

void main() 

{ class test T; 

fun1(T); 

return 0; 

} 

• Třída určuje funkce, které jsou spřátelené a chrání tím data před nekontrolovaným 

použitím. 

• Jako spřátelené funkce mohou být deklarovány i metody jiných objektových typů. 

• Mimo deklarace spřátelených funkcí se může deklarovat celá třída jako spřátelená. 

Přetěžování a předefinování 

Pokud se v odvozené třídě deklaruje nevirtuální metoda se stejným jménem jako v bázové 

třídě, zastíní deklarace v odvozené třídě deklaraci z bázové třídy. To je stav, kdy zděděná 

metoda nebude přímo dostupná i když je odlišná. Pro její použití se musí použít jméno 

předka. 

Příklad 17 

class Zaklad 

{ public: 

void fun1(int); 

}; 

class Odvozena:Zaklad 

{ public: 

void fun1(char*); 

}; 

void main() 

{ Odvozena odv; // Případ třídy Odvozena 

odv.fun1(3); 

// Chyba 

odv.Zaklad::fun1(3); // Správně 

return 0; 

} 

Zvláštní metody 

Mezi zvláštní metody patří vytvoření případu – konstruktor, který má několik pravidel 

použití. Základní jsou: 

• Konstruktor má vždy stejné jméno jako jeho třída 

str. 28



• Konstruktor nemá žádnou návratovou hodnotu 

• Pokud konstruktor nedeklarujeme, překladač v třídě sám vytvoří veřejně přístupný 

konstruktor bez parametrů 

• Pokud explicitně deklarujeme jakýkoliv konstruktor, nebude překladač žádný další 

vytvářet 

• Konstruktory mohou být přetěžovány 

• Konstruktory se nedědí, konstruktor potomka automaticky volá konstruktory 

bezprostředních prvků 

• Nelze deklarovat ukazatel na konstruktor 

• Konstruktory, které mají právě jeden parametr, mohou provádět konverzi na typ své 

třídy 

• Konstruktor se volá při dynamické alokaci případu pomocí operátoru new. 

Příklad 18 

class test 

{ int privat; 

public: 

test(int i){privat=1;} 

explicit test(float g){privat=(int)g;} 

}; 

//Konstruktor 

void main() 

{ test pripad(100); 

test pripad2=100; 

test pripad3(3.2); 

test pripad4=3.2; 

return 0; 

} 

//Implicitní konverze 

//Chyba: explicitní konverze parametru není 

Inicializační část konstruktoru 

Inicializační část je určena k inicializaci datových složek třídy. Má tvar 

identifikátor_složky (hodnota) 

identifikátor_složky (SeznamParametruKonstruktoru) 

identifikátor_třídy (SeznamParametruKonstruktoru) 

Příklad 19 

class test 

{ int i; 

public: 

test(int j):i(j){} 

}; 

//do i je uložena hodnota parametru 

class testB 

{ test T; 

int x; 

public: 

testB(int y):x(y-1), a(10){fce1();} 

}; 

str. 29



Zrušení případu - destruktor 

Destruktory se volají automaticky při zániku případu (například delete - zrušení 

dynamické proměnné). 

• Destruktor nemá žádnou návratovou hodnotu 

• Pokud v třídě nedeklarujeme explicitně destruktor, vytvoří si překladač veřejně 

přístupný standardní destruktor 

• Destruktor se nedědí 

• Nelze definovat ukazatel na destruktor 

• Destruktor nemá žádné parametry 

• Destruktory mohou být i virtuální 

• Destruktory můžeme explicitně volat. 

3.3 Ukazatel this 

Každý případ má svou kopii nestatických datových složek třídy. Metody jsou v paměti 

uloženy jen jednou a používají je všechny případy třídy společně. Je-li v nestatické metodě 

odkaz na nestatickou datovou složku jejím identifikátorem, je to odkaz na aktuální případ 

vytvořené třídy. 

Ukazatel na aktuální případ 

Na aktuální případ se můžeme odkázat klíčovým slovem this. Ukazatel this se předává 

jako skrytý parametr, programátor jej tedy nemusí deklarovat. Jednoduchý příklad ukazuje 

použití ukazatele. 

Příklad 20 

class complex 

{ double Re, Im; 

public: 

complex(double _Re, double _Im):Re(_Re), Im(_Im){} 

double Real(); 

double Imag(); 

}; 

double complex::Real(){return Re;} 

double complex::Imag(){return Im;} 

V metodě Real() je příkaz return Re vlastně return this->Re. 

3.4 Agregáty 

Agregáty jsou struktury, které nemají 

• žádný uživatelem definovaný konstruktor 

• nestatické prvky, deklarované jako private nebo protected 

• nestatické reference 

• nestatické konstantní složky (const) 

• ve svojí deklaraci uveden předek 

str. 30



• bázové třídy 

• virtuální členské funkce. 

Agregáty je možné inicializovat výčtem hodnot ve složených závorkách. 

Příklad 21 

class test 

{ public: 

struct Struktura 

{ int i; 

float p; 

}Str; 

void fun1(); 

}; 

test T = {3,3.1415926}; 

3.5 Oblasti platnosti a dosažitelnosti identifikátorů 

Blok 

Funkce 

Prototyp 

funkce 

Soubor 

Třída 

Identifikátor deklarovaný v těle funkce je platný v místě jeho deklarace a končí 

na konci bloku. Formální parametr funkce je platný na začátku jeho deklarace 

a končí na konci těla funkce. 

Oblast platnosti se týká pouze návěští pro příkaz skoku. 

Oblast platnosti končí s koncem prototypu. 

Oblast platnosti se týká globálních identifikátorů (deklarované mimo tělo 

funkce). Platnost začíná v místě deklarace a končí na konci souboru. 

Oblast platnosti identifikátoru definovaného uvnitř třídy začíná v místě 

deklarace, obsahuje celé tělo třídy, těla všech metod, specifikace formálních 

parametrů a jejich implicitních hodnot a také inicializační část konstruktorů 

i mimo tělo třídy. 

Jména deklarovaná uvnitř třídy jsou dostupná i mimo třídu když jsou zapsány 

případem (operátor tečka), ukazatelem na případ (operátor ->), někdy 

jménem třídy (operátor ::). 

3.6 Prostory jmen 

Tyto prostory jsou nástroje vhodné pro organizaci identifikátorů v programu, aby 

nedošlo k jejich konfliktům v rozsáhlém programu. Deklarace prostoru jmen je 

namespace [jmenovka]{deklarace} 

• Najde-li překladač druhý prostor jmen se stejnou jmenovkou, bude jej považovat za 

rozšíření prostoru. 

str. 31



• Prostory jmen můžeme deklarovat pouze na úrovni souboru nebo uvnitř jiného 

prostoru jmen. 

• Deklarujeme-li v daném prostoru jmen třídu, pak její spřátelené funkce (deklarované 

uvnitř třídy), patří také do tohoto prostoru jmen. 

• Klíčovým slovem using lze zpřístupnit objekt z libovolného prostoru jmen bez 

nutnosti opakované deklarace. 

using jmenovka :: identifikátor //zpřístupní se daný identifikátor 

using namespace jmenovka //zpřístupní se všechny identifikátory 

//z daného prostoru 

Příklad 22 

namespace test 

{ int i=1; //test::i 

void fun1(int); 

struct T 

{ int i=2; //test::T::i 

}; 

} 

namespace test 

// pokračování 

{ int i=3; //nepřípustné- opakovaná definice 

void fun1(float); 

// přetížení 

void fun2(float); 

// korektní 

namespace 

// nepojmenovaný prostor 

{ int i=4; //test::T::i 

}; 

} 

void test::fun1(float x); 

// definice vně prostoru 

{ return i; // test::i 

} 

Příklad 23 

namespace A 

{ int i=1; 

} 

namespace B 

{ int i=2; 

using namespace A; 

} 

void main() 

{ i=i+1; // Chyba - není zpřístupněn 

A::i=A::i+1; 

// Správný zápis 

using namespace B; 

i=i+6; 

// Není jasné o který prostor jde A::i nebo B::i 

return 0; 

} 

3.7 Paměťové třídy 

Při deklaraci můžeme ještě zadat pro proměnnou její paměťovou třídu. Paměťová třída 

a místo deklarace určují viditelnost a dobu života proměnné. 

str. 32



• auto proměnné jsou lokální v bloku 

• register proměnné jsou automatické proměnné, u kterých požadujeme umístění 

do registru procesoru. 

• static proměnná je globální a má omezenou viditelnost. 

• extern se přiřazuje proměnné nebo funkci z vnějšího přístupu 

• mutable povoluje měnit konstantní objekty. 

3.8 Kontrolní otázky 

1. V čem spočívají výhody tříd 

2. Jakou roli v úspoře času a prostoru při programování v C++ hierarchické členění 

objektů 

3. Existuje nějaké rozdělení přístupu k prvkům třídy 

3.9 Úkoly 

1. Sestavte program pro načtení a uložení dat na disk s daty z tabulky jednoduché 

aplikace. Využijte maximálně vlastností OOP. 

2. Sestavte program pro zadání a řešení soustavy lineárních rovnic Gaussovou eliminační 

metodou. Využijte maximálně vlastností OOP. 

str. 33



4 Objekty 

S označením objekt se setkáme v životě i v programovacích jazycích. Tvůrci 

programovacího jazyka se snaží pro jeho srozumitelnost a pochopení napodobit vlastnosti 

prvků a názvosloví běžné v každodenním životě. Objektem je nazýván jak obraz třídy, tak 

i její případ (instance). Někdy se používá název objekt i pro přístupnou část paměti 

(konstanta, proměnná, pole proměnných, funkce, ...). 

4.1 Přiřazování objektů 

Předpokládejme, že objekt je popsán třídou. Příklad ukazuje jednoduchou operaci se dvěmi 

objekty. Jde o přiřazení objektu O2 objektu O1. Data obou jsou totožná, ale přitom jsou O1 

a O2 objekty oddělené. 

Příklad 24 

using namespace A; 

class test 

{ int a,b; 

public: 

void fun1(int i, int j){a=i;b=j} 

void show(){cout



int get_a(){return a;} 

}; 

int kva_a(test x) 

// kva_a přebírá argument třídy test 

{return x.get_a()* x.get_a(); // Provede se kvadrát argumentu 

} 

int main() 

{ test a(5),b(6); // a a b jsou případem třídy test 

cout



}; 

public: 

void show(){cout



5 Operátory 

V této části se budeme blíže zabývat vlastnostmi operátorů. 

5.1 Přehled operátorů 

V následující tabulce je uveden seznam a původní význam operátorů. 

OPERÁTOR POPIS POZN. 

+ součet operandů (binární) 

+ identita (unární) 

- rozdíl operandů (binární) 

- změna znaménka (unární) 

+= součet operandů a přiřazení výsledku levému operandu 

-= rozdíl operandů a přiřazení výsledku levému operandu 

* aritmetické násobení 

* přístup k hodnotě proměnné (ukazatel) 

*= aritmetické násobení a přiřazení výsledku levému operandu 

/ aritmetický podíl dvou operandů 

/= aritmetický podíl dvou operandů výsledek je přiřazen levému 

% výsledek po celočíselném dělení 

%= výsledek po celočíselném dělení přiřazen levému operandu 

! logická negace 

not 

logická negace 

!= logická relace nerovná se 

not_eq logická relace nerovná se 

& 

adresa operandu (unární) 

& 

konjunkce po bitech (binární) 

bitand konjunkce po bitech (binární) 

&= 

konjunkce po bitech a výsledek přiřadí levému operandu 

and_eq konjunkce po bitech a výsledek přiřadí levému operandu 

&& 

konjunkce- logický součin 

and 

konjunkce- logický součin 

(int).... přetypování na int, lze libovolně použít 

dynamic_cas 

t 

přetypování v rámci dědické hierarchie s dynamickou 

kontrolou typů 

static_cast změna typů objektů a standardní C/C++ 

const_cast změna typů, kdy se předávají nebo odstraňují modifikátory 

const a volatile 

reinterpret 

_cast 

nepřenositelné přetypování 

, čárka, operátor pro sekvenční vyhodnocování 

++ zvýšení hodnoty operandu o jednu 

-- snížení hodnoty operandu o jednu 

-> přístup ke složce případu (instance) prostřednictvím 

ukazatele 

str. 37



. tečka, přístup ke složce případu prostřednictvím případu 

= přiřazení 

== logická relace rovno 

< logická relace menší než 

> logická relace větší než 

logická relace větší nebo rovno 

>= posunutí bitů doprava a přiřazení výsledku levému operandu 

: podmíněný výraz 

[] indexování pole 

() volání funkce 

^ 

bitová nerovnost XOR 

xor 

bitová nerovnost XOR 

^= bitová nerovnost a přiřazení výsledku levému operandu 

xor_eq bitová nerovnost a přiřazení výsledku levému operandu 

| logická relace disjunkce – OR po bitech 

bitor logická relace disjunkce – OR po bitech 

|= logická relace disjunkce po bitech a přiřazení výsledku levému 

operandu 

or_eq logická relace disjunkce po bitech a přiřazení výsledku levému 

operandu 

|| logická relace disjunkce - OR 

or 

logická relace disjunkce - OR 

~ doplněk (binární) 

compl doplněk (binární) 

: inicializace třídy 

:: operátor rozsahu, zpřístupnění globálního jména, jména ze tříd 

a prostorů jmen 

.* přístup k hodnotě třídy s pomocí případu 

->* přístup k hodnotě třídy s pomocí ukazatele na případ 

sizeof vrací velikost operandu v bytech 

typeid dynamické určení typu 

new 

dynamické přidělení paměti 

delete uvolnění dynamicky přidělené paměti 

delete[] uvolnění dynamicky přidělené paměti pole 

# převod parametru makra na řetězec (preprocesor) 

## spojování symbolů (preprocesor) 

defined test na přítomnost definovaného makra (preprocesor) 

Podle počtu operátorů můžeme operátory klasifikovat na 

• unární (+, -,&, *, !, ~, ++, --, sizeof ) 

• binární (=, +=, - =, *=, /=,



by měly být stejného typu. Pokud nejsou, provede se jejich převedení (konverze). Konverze 

má svá pravidla, ale ze zkušeností vyplývá, že na ně nelze spoléhat. Mohou způsobit při 

přenosu zdrojového kódu a následném překladu nedozírné komplikace, proto dobří 

programátoři řádně definují převody již při psaní zdrojového kódu programu. Nebudeme se 

dále zabývat pravidly konverze. Následující příklady ukazují některá použití operátorů. 

5.2 Popis a užití operátorů 

Unární operátory + ,- mění hodnoty operandu. Pro binární operátory +, -, /, * , % platí 

známá pravidla. Přiřazovací operátory jsou obdobně používány jako v jazyce C a ostatních 

jazycích. V jazyce C jsme se seznámili se složenými operátory. 

Příklad 28 

void main() 

{ int a,b; 

a=1; 

b=2; 

a+=b; 

return 0; 

} 

// ekvivalent a=a+b 

Použití relačních a logických operátorů je standardní jako v jazyce C, podobně přístup 

k datům je shodný jako v jazyce C. Výjimečně mohou nastat obtíže v přístupech k objektům. 

Jednoduché příklady ukazují možnosti použití přístupu. 

Příklad 29 

struct test 

{ char jmeno[100]; 

int cislo_vyr; 

}; 

void main() 

{ test auto; 

strcpy(auto.jmeno, ”Jaguar”); 

auto.cislo_vyr=51023659874515926; 

return 0; 

} 

Příklad 30 

struct test 

{ char jmeno[100]; 

int cislo_vyr; 

}; 

void main() 

{ struct test auto; 

struct test* p_auto=&auto; 

strcpy(p_auto->jmeno, ”Jaguar”); 

p_auto->cislo_vyr=51023659874515926; 

str. 39



return 0; 

} 

Bitové operátory jsou definovány pouze pro celočíselné typy proměnných. V operandech se 

pracuje s jednotlivými bity. Patří sem operace AND, OR, NOT, COMPL. Jako příklad práce 

s bitovými operátory lze uvést: 

Příklad 31 

0110 0001 znak á´ 

&1101 1111 maska 

0100 0001 znak Á´ 

0100 0001 znak Á´ 

|0010 0000 maska 

0110 0001 znak á´ 

0001 1001 

^0000 1100 

0001 0101 

Nepoužívané nebo často neznámé jsou operátory new a delete, které slouží k přidělování 

a uvolňování dynamické paměti. Nahrazují dříve používané funkce ze skupiny malloc() 

a free(). New umožňuje přidělit dynamicky alokovaným objektům počáteční hodnotu. 

Delete umožní vytváření dynamicky alokovaných polí. Ukážeme si na několika příkladech 

jejich použití. 

Příklad 32 

#include 


int main() 

{ int *p; 

p = new int; 

// přidělené místo pro typ integer 

*p = 1000; //na adresu p se uloží 1000 

cout



char te[sizeof(test)]; 

x_test=new test[10]; 

x_test=new(te) test; 

test * utest = new(nothrow) test(5); 

//deklarace třídy 

//alokace pole 

//konstrukce případu třídy 

//nevyvolává výjimky, 

//alokuje případ třídy 

Objekty vytvořené pomocí new mají neomezenou dobu trvání. Paměťová místa se musí 

uvolnit operátorem delete. 

Příklad 34 

class test *p =new test[10]; 

delete[] p; 

int **xx = new int*; 

delete x; 

//alokace 

//uvolnění paměti 

//alokace 

//uvolnění paměti 

V následující části textu se velmi stručně dotkneme přetypování. Klasické přetypování z C je 

asi takovéto: 

Příklad 35 

int a; // 

double b,c; 

c=(double) a/b; 

Ke komplikovanějšímu přetypování, jako je například přetypování ukazatele, je určen 

operátor dynamic_cast. Ukažme si na příkladu jeho použití. 

Příklad 36 

class zakl 

{ public: 

virtual void fce(); 

}; 

class dcera: public virtual zakl 

{ public: 

virtual void fce(){} 

virtual void gfce(){int a=1;} 

}; 

void pracuj(zakl *ub) 

{ dcera* up = dynamic_cast (ub) 

if(up) up->gfce(); 

else return -1; 

}void main() 

{ zakl X; 

dcera Y; 

pracuj (&Y); // Správné přetypování, return 1 

pracuj (&X); // Chyba přetypování, return -1 

} 

str. 41



5.3 Přetěžování operátorů 

Některé operátory (většina) v C++ lze předefinovat. Přetížené operátory se definují jako 

funkce (operátorové funkce). Při práci s operátory se mohou rozdělit do čtyř skupin: 

1. Operátory ::, :, ., .*, sizeof, typeid, dynamic_cast, 

static_cast, reinterpret_cast, const_cast, defined, #, ## 

NELZE PŘETĚŽOVAT. 

2. Operátory ->, [], (), =, (typ) lze přetěžovat pouze jako nestatické metody 

objektových typů. 

3. Ostatní operátory s výjimkou new a delete lze přetěžovat jako nestatické metody 

objektových typů. 

4. Operátory new a delete lze přetěžovat jako statické metody objektových typů nebo 

jako obyčejné funkce. 

Přetěžování operátorů má také svá pravidla, například : 

• nelze definovat nové operátory 

• není přípustné měnit charakteristiky operátorů (počet operandů, prioritu,…) 

• nelze měnit definici operátoru pro standardní datové typy 

• jméno operátorové funkce se vždy skládá z klíčového slova operator a symbolu 

operátoru 

• kromě new a delete operátoru není pro žádný z operátorů předepsán typ vrácené 

hodnoty 

Příklad 37 

class complex 

// komplexní čísla 

{ double re,im; 

public: 

complex (double r, double i); // konstruktor 

complex operator –(); 

// unární mínus 

friend bool operator !(complex&); //logická negace 

}; 

complex complex::operator-() // vrati komplexni cisla 

{ return complex (-re, -im); // s opacnym znamenkem 

} 

complex operator!(complex& c) // pokud je aspon jedna slozka 

{ if(c.re || c.im) // nenulova, vrati true 

return true; 

else 

return false; 

} 

void main() 

{ complex c(0,0), d(0,1); 

c=-d; 

if(!c) test(c); 

return 0; 

} 

// ekvivalent c=d.operator-() 

str. 42



V následujícím příkladu (Příklad 38) si ukážeme přetížení operátoru ++ vzhledem ke třídě 

pretiz. Operátor ++ navyšuje své operandy. Zde ++ modifikuje objekt, nad nímž operuje. 

Funkce vrací objekt, který inkrementuje. To umožňuje, aby mohl být inkrementační operator 

použit i jako součást většího příkazu (např. o2=++o1;). 

Příklad 38 

class pretiz 

{ int x, y; // hodnoty souřadnic 

public: 

pretiz() { x=0; y=0; } 

pretiz(int i, int j) { x=i; y=j; } 

void get_xy(int &i, int &j) { i=x; j=y; } 

pretiz operator++(); 

}; 

pretiz pretiz::operator++()//Přetížení operátoru ++ pro třídu pretiz 

{ x++; 

y++; 

return *this; 

} 

int main() 

{ pretiz o1(10,10); 

int x, y; 

++o1; 

// inkrementuje objekt 

o1.get_xy(x, y); 

cout



5.4 Úkol 

1. Sestavte program pro změnu editovaných písmen z malé na velkou abecedu 

a obráceně. 

str. 44



6 Dědičnost 

Dědičnost je jedním ze základních vlastností a prvků OOP, který umožňuje rychlejší 

sestavení struktury vlastností objektů. Původní – bázové třídy slouží jako základ pro nové 

– odvozené třídy, potomky nebo dceřiné třídy. Třídy vázané dědičnými vlastnostmi se také 

označují jako dědická hierarchie. 

Existuje několik forem dědičnosti. 

• Jednoduchá – jedna bázová a jedna odvozená. 

• Vícenásobná – jeden potomek má více předků. 

Odvozená třída dědí vlastnosti předků, bude obsahovat všechny nestatické datové složky 

předků, bude používat jejich metody, typy a statické složky podle definovaných práv. Některá 

pravidla lze bodově shrnout: 

• Kritérium sdílení – odvozené třídy by měly korektně sdílet vlastnosti základní třídy. 

• Kritérium nezávislosti – vlastní definice odvozené třídy by neměly ovlivňovat použití 

zděděných vlastností. 

• Kritérium specializace – je-li odvozená třída speciálním případem základní, použije se 

k odvození polymorfismu – virtuálních metod. Speciální případy tříd nejsou rozdílné 

úrovně v hierarchii. 

• Kritérium jednotnosti – dědičnost by měla zajistit rovnoprávnost tříd – jednotný 

způsob implementace. 

6.1 Syntaktický zápis 

Zápis dědičnosti je podle následujícího tvaru 

klíč jméno_třídy:seznam_bázových_tříd 

{ 

složky_třídy 

}; 

kde jsou klíč .... class, struct , jméno_třídy je identifikátor odvozené třídy, 

seznam_bázových_tříd je výběr tříd, jejichž vlastnosti má odvozená třída dědit a způsob 

dědění. Položka má tvar [virtual][specifikátor_přístupu]jméno_bázové_třídy 

, specifikátor_přístupu je jeden z public, protected, private. 

Složky_třídy jsou definice odvozených tříd. Jednoduchou ukázkou zápisu dědění tříd je 

Příklad 40. 

Příklad 40 

class zakl 

// bázová třída 

{ int i; 

public: 

void nastav_i(int n){i=n;} 

int vezmi_i(){return i;} 

}; 

str. 45



class odvozena: public zakl // odvozená třída 

{ int j; // přidána další proměnná 

public: 

void nastav_j(int n){j=n;} // přidána další funkce 

int nasobeni (){return j*vezmi_i();} //přidáno násobení i*j 

}; 

int main() 

{ odvozena o1; // o1 je případ odvozené třídy 

o1.nastav_i(10); // nastaví se i=10 

o1. nastav_j(4); // nastaví se j=4 

cout



Příklad 42 

class zakl_x 


{ int fce(); // private 

public: 

int j; 

// public 

}; // 

class odvozena_x: private zakl_x // odvozená třída 

{ int i; // private 

public: 

using zakl_x::fce; // opět public, změna pomocí using 

}; 

Dědická práva platí u všech složek i metod třídy. 

Příklad 43 

class zakl_x 


{ int prom_a, prom_b; // private 

public: 

int sou_a(){return prom_a;}; 

int sou_b(){return prom_b;}; 

zakl_x: prom_a(10), prom_b(20) {}; 

}; 

class odvozena_x: public zakl_x // odvozená třída 

{ int suma; // private 

public: 

odvozena_x: suma(0){}; 

int scitej(); 

{ suma+=prom_a+prom_b; 

return suma; 

} 

};V tomto příkladě zřejmě překladač ohlásí chybu, protože je proveden nekorektní zápis 

odvozené třídy. Složky prom_a, prom_b jsou v odvozené třídě nepřístupné. Jsou dvě 

možnosti změny. První je, že v základní třídě se změní z private na protected. 

Příklad 44 

class zakl_x 


{ protected: // smí používat potomek 

int prom_a, prom_b; // private 

public: 


int sou_b(){return prom_b;}; 

zakl_x: prom_a(10), prom_b(20) {}; 

}; 

Druhá metoda je založena na změně přístupových práv. 

Příklad 45 



public: 

odvozena_x: suma(0){}; 

int scitej(); 

str. 47



}; 

{ suma+=sou_a()+sou_b(); 

return suma; 

} 

Konstruktory a destruktory tříd se nedědí, ale při tvorbě případu odvozené třídy jsou zděděné 

datové složky inicializovány konstruktorem základní třídy. 

Příklad 46 

class zakl_x 


{ int prom_a; // private 

public: 


zakl_x(void): prom_a(10) {}; 

zakl_x(int prom_b): prom_a(prom_b) {}; 

}; 



public: 

odvozena_x(void): suma(0){}; 

odvozena_x(int prom_b, int prom_c): zakl_x(prom_b), 

suma(prom_c){}; 

void scitej(zakl_x& b); 

}; V deklaraci konstruktoru odvozena_x(void) 

nevoláme konstruktor předka. Překladač použije konstruktor zakl_x(void). V konstruktoru 

odvozena_x(int) se volá konstruktor zakl_x(prom_b). 

6.3 Úkol 

1. Sestavte program pro měřicí ústřednu s okny měřicího zařízení (ručkový měřicí 

přístroj, osciloskop) tak, aby byly využity vlastnosti dědičnosti měněné podle 

nastavení uživatele. 

str. 48



7 Polymorfismus 

Polymorfismus souvisí s principy dědičnosti. Je to jev, kdy jedna metoda (ekvivalentní 

funkce) je v různých třídách svázaných dědičností, implementována rozdílně. Vhodné je 

používat dědění pomocí společné bázové třídy. V odvozených třídách jsou metody 

předefinovány a pozmění se tak účel metody. Metody, které se mají v odvozených třídách 

změnit, se deklarují s klíčovým slovem virtual. 

Příklad 47 

struct bod_1 {double x,y;}; 

class kres_obj 


{ protected: 

bod_1 ref_bod; 

virtual int kresli(); // bude se měnit v odvozených třídách 

}; 

{ //nakreslí se bod v daných souřadnicích 

//........ 

}; 

class obdelnik: public kres_obj // odvozená třída 

{ protected: 

bod_1 rohy[4]; 

virtual int kresli(); // bude se měnit 

}; // 

{ // nakreslí obdélník o daných rozměrech 

//........ 

}; 

class kruznice: public kres_obj // odvozená třída 

{ protected: 

bod_1 stred; 

float r; 

virtual int kresli(); // bude se měnit (nakreslí kružnici) 

}; // 

{ //nakreslí kružnici o daných rozměrech 

//........ 

}; 

7.1 Úkol 

1. Sestavte program, který provede v okně vykreslení základních geometrických 

obrazců – kružnice, elipsa, čtverec, obdélník, kosočtverec, přímka, trojúhelník,...., 

(ukázka struktury programu viz Příklad 47). 

str. 49



8 Přetěžování funkcí 

O přetěžování funkcí jsme se již krátce zmínili v předcházejících kapitolách. Nyní se 

ještě k tomuto tématu vrátíme. 

8.1 Přetěžování konstruktorů 

Pro snazší programování a nezatěžování schopností programátora jsou zaváděny 

všechny systémy přetěžování. Patří mezi ně i přetěžování konstruktorů. Mimo jiné pomáhá 

přetěžování konstruktorů k mnohotvárnosti používání polí, tvorbě kopírovacích konstruktorů. 

Při zavádění tříd můžeme, ale nemusíme vytvářet vlastní konstruktory. 

Příklad 48 

class test 

{ int i; 

public: 

}; 

test(){i=0} 

test(int n){i=n} //s inicializátorem 

int getx() {return i}; 

// přetížení konstruktoru dvojí způsobem 

//bez inicializátoru 

int main() 

{ test o1(10); // deklarace s počáteční hodnotou 

test o2; 

// deklarace bez inicializátoru 

cout



}; 

test(){i=0} 

test(int n){i=n} 

int getx() {return i}; 

//bez inicializátoru 

//inicializátor 

int main() 

{ test o1[10]; // deklarace pole bez inicializátorů 

test o2[3]={1,2,3}; // deklarace s inicializátory 

return 0; 

}; 

Přetěžováním se dosáhne toho, že programátor si pohodlně může vybrat libovolný typ 

inicializace objektu. Při přetěžování se může použít prvek – standardní argument. Je to 

způsob předávání parametrů při volání funkci, které je zkráceným zápisem přetěžování 

funkce. Zadání standardního argumentu může vypadat například takto: 

void test_f (int a=0, int b=0); 

Nyní funkce může být volána třemi způsoby: 

1. test_f (); //a,b=0 

2. test_f (15); //a=15,b=0 

3. test_f (1,56); //a=1, b=56 

Důležitým konstruktorem je tzv. kopírovací konstruktor. Ten se volá při definici 

instance, která má jako inicializátor jinou instanci téže třídy nebo v případě vytváření 

dočasných instancí, např. v přiřazení A = B + C. Nejprve je nutné definovat dva druhy 

kopírování instancí. Prvním typem je plytké kopírování, kdy přiřazením instancí A = B pouze 

zkopírujeme atributy (obsahy) datového prostoru zdrojové instance. Tato metoda selhává 

v případě, kdy se v datovém prostoru instance objeví ukazatel do místa v paměti. Pouhým 

přiřazením A = B totiž oba ukazatele těchto dvou instancí ukazují na stejné místo v paměti. 

Tomu zabráníme kopírováním celých dat (ne pouhých adres) – tzv. hlubokým kopírováním. 

Definujeme tedy kopírovací konstruktor – metoda určující pravidla kopírování dat z jedné 

instance do druhé. 

Příklad 50 

class komplex 

{ 

int *Re, *Im; // ukazatel na realnou a imag. část kompl. čísla 

public: 

komplex(int Re, int Im) 

{ 

// konstruktor se dvěma parametry 

// nastaví reálnou část na x a imaginární na y 

this->Re = new int(Re); 

this->Im = new int(Im); 

} 

komplex(const komplex &src) 

{ 

// kopírovací konstruktor 

// zkopiruje hodnotu realné a imaginární části 

str. 51



}; 

} 

this->Re = new int(*src.Re); 

this->Im = new int(*src.Im); 

Na tomto příkladu je vidět definice kopírovacího konstruktoru, který se stará o kopírování dat 

a ne adres v datovém prostoru instance. Nyní můžeme vytvořit instanci třídy komplex takto: 

komplex A(1,2); 

komplex B(A); 

Komplexní číslo A bude ve tvaru 1+2i a komplexní číslo B také, protože díky kopírovacímu 

konstruktoru dojde ke kopii dat z dynamicky alokovaných proměnných. Dále můžeme psát: 

A = B + C; 

Přetížením operátoru + můžeme sečíst dvě komplexní čísla. Zde vznikne kopírovacím 

konstruktorem dočasná instance (X), která obsahuje jejich součet. Přetížením operátoru = dále 

můžeme data z dočasné instance kopírovat do výsledné instance A. 

8.2 Anachronismus přetěžování 

V době vzniku C++ bylo pro přetěžování vymezeno klíčové slovo overload. Nyní je 

zastaralé a není používáno, ale je možné se s ním setkat ve starších zdrojových textech. Jeho 

tvar a používání je 

overload name_fce; 

name_fce je jméno přetěžované funkce. Příkaz předchází deklaracím přetěžované funkce. 

8.3 Přetěžování a nejednoznačnost 

Při používání přetěžování funkcí se může do programu zanést nejednoznačnost. Bývá to 

převodem typů, pomocí parametrů odkazů, pomocí standardních argumentů. Někdy ale 

nejednoznačnost je vnesena samotným přetížením funkce. Ukázkou je následující příklad. 

Příklad 51 

float fce_1(float x) 

{ return x/2.0; } 

double fce_1(double x) 

{ return x/3.0; } 

int main() 

{ float x=1.01; 

dougle y=1.01, a; 

a= fce_1(x); // jednoznačné 

a= fce_1(y); // jednoznačné 

a= fce_1(48);// nejednoznačné, převod 48 na double nebo float 

return 0; 

str. 52



}; 

Podobně by se s různými typy dalo pokračovat. 

8.4 Úkol 

1. Sestavte program, který pomocí zjednodušeného zápisu umožní více typů 

zobrazení aktuálního data, hodiny. 

str. 53



9 Šablony funkcí a tříd 

Šablony jsou vzory, podle kterých překladač může sestavit skupiny podobných vlastností. 

Tyto skupiny se nazývají případy (instance) šablony. Deklarace šablony má tvar 

template deklarace; 

template je klíčové slovo, které uvádí deklaraci šablony, seznam_parametru je seznam 

formálních parametrů, deklarace je deklarace obyčejné funkce, metody, objektového typu, 

statické datové složky objektového typu. 

Šablony nemohou být lokální ve funkcích, šablony funkcí se mohou deklarovat na 

úrovni souboru, šablony objektových typů můžeme deklarovat na úrovni souboru, jako složky 

objektových typů nebo šablon objektových typů. Lokální třídy nemohou obsahovat deklarace 

šablon. Dále existuje ještě několik pravidel nebo zaběhlých použití šablon. 

9.1 Parametry šablon 

Rozlišují se hodnotové, typové a šablonové parametry. Typový parametr zastupuje 

datový typ, hodnotový parametr zastupuje konstantu. Hodnotové parametry se deklarují 

podobně jako formální parametr funkce. Typový parametr se deklaruje pomocí klíčového 

slova class. Pokud předepíšeme, že parametr je šablona, získáme poslední typ parametru. 

Příklad 52 

class test 

class test =int 

typename test 

typename test=float 

template< class test, ...>class test_1 

// první tvar 

// druhý tvar 

// třetí tvar 

// čtvrtý tvar 

// pátý tvar 

templateclass test_1=Jmeno_Sablony 

//šestý tvar 

První a třetí tvar představuje typový formální parametr bez implicitní hodnoty. Druhá a čtvrtá 

možnost prezentuje typový formální parametr s implicitní hodnotou. Pátý a šestý tvar 

zachycují šablonový formální parametr. 

9.2 Šablony funkcí 

Zápis šablony funkce je následující 

template typ jmeno (seznam_parametru_fce ) 

{ telo fce 

}; 

Uveďme si na příkladech. 

Příklad 53 

str. 54



templatetest ma(test a, test b) 

{ return a>ba:b; 

}; 

Příklad 54 

#include 


template void prohod(X &a, X &b) //šablona funkce 

{ X pom; //X je vlastníkem prostoru 

pom = a; 

// vloží a do pom 

a = b; 

//prohodí b do a 

b = pom; 

//vloží do b hodnotu z pom 

} 

int main() 

{ 

int i=100, j=200; 

float x=100.1, y=200.3; 

cout




template class mojetrida 

{ T1 i; 

T2 j; 

public: 

mojetrida(T1 a, T2 b) { i = a; j = b; } 

void vypis() { cout



10 Obsluha výjimek 

Jazyk C++ má vestavěn mechanismus pro ošetření chyb nazvaný obsluha výjimek. 

Ošetření se děje pomocí klíčových slov try, catch, throw. Mechanismus pro zpracování 

výjimek dokáže oddělit běžný zdrojový kód od kódu pro zpracování chyby. Syntaxe je : 

try { pokusny_blok } 

catch(typ1[identifikator]) 

{ telo_osetreni_vyjimky 

} 

catch(typ2[identifikator]) 


} 

catch(typn[identifikator]) 


} 

pokusny_blok je kód, v němž může nastat výjimka, v bloku catch je uveden případ pro 

zadanou výjimku. Pokud nastane výjimka a není zde uvedeno tělo catch, může dojít 

k nekorektnímu ukončení programu. Nenastane-li ani jedna výjimka, všechny bloky catch 

jsou přeskočeny. 

Nechceme-li přístup k samotné výjimce, v klíčovém slovu catch specifikujeme pouze 

typ. Pro upřesnění, které výjimky se smějí rozšířit z těla funkce, se používá funkce throw. 

Jednoduchý program ošetření výjimek je uveden jako Příklad 57. 

Příklad 57 

void test(int x)throw(int, char, double) 

{ if(x==0) throw x; //odmítne int 

if(x==1) throw ’abcd’; //odmítne char 

if(x==2) throw 122.333; //odmítne double 

} 

int main() 

{ int err=0; 

try{ test (0)} 

catch(int i) { err=1;} 

catch(char c) { err=2;} 

catch(double d) { err=3;} 

return err; 

} 

V příkladu je definovaná funkce test, která zachycuje výjimky s omezené množiny (celé 

číslo, znak, reálné číslo s dvounásobnou přesností). V hlavní funkci se deklaruje proměnná 

err a volá se blok try s funkcí test. Pak proběhne zachycení výjimek. Podle jejich pořadí 

je do proměnné err zapsána hodnota, která se předá na konci hlavní funkce. 

Jako doplnění pro ošetření výjimek slouží funkce unexpected(), terminate(), 

set_unexpected(), set_terminate(). Funkce unexpected(), terminate() volají 

str. 57



systém v případě ukončení programu. Funkce set_unexpected(), set_terminate() 

mohou změnit nastavení funkcí unexpected(), terminate(). 

Příklad 58 

#include 


int main() 

{ cout



10.1 Úkol 

1. Pro vámi sestavený program nastavte kontrolu neočekávaných výjimek tak, 

abyste jej ošetřili proti nestandardnímu ukončení. 

str. 59



11 Závěr 

Společně jsme prošli základy programování v jazyce C++ a bodově se dotkli některých 

hlavních témat. Měli bychom mít osvojeny základní návyky programátora jako je např. 

využívání různých druhů vysvětlujících textů. Kurz nabízel použití vývojového prostředí 

Borland C++ Builder pro platformu MS Windows a z 90 % se zaměřil na programy 

klasického typu (událostmi řízené programování se probíralo v kurzu Počítače 

a programování II). Učinili jsme první kroky k schopnosti vyvíjet praktické aplikace pro 

řešení problémů z oblasti elektrotechniky, informatiky a komunikačních technologií. Nejlepší 

školou programování je vlastní práce s jasně definovaným cílem. Zde byly pokryty základy 

programování, které budete muset již sami rozvíjet, seznamovat se s dalšími možnostmi, které 

Borland C++ Builder nebo jiné nadplatformní programy nabízí a sledovat vývoj, jímž 

programovací nástroje procházejí. Velmi rychle se měnící informační technologie způsobují, 

že programátoři musejí nové informace a trendy studovat celý život. Při tomto neustálém 

studiu vám přeji mnoho úspěchů a pevně věřím, že nabyté znalosti využijete dále, např. při 

řešení ročníkových projektů, bakalářských a diplomových prací. 

11.1 Literatura 

[1] ECKEL, B. Myslíme v jazyku C++. Praha: Grada Publishing, 2002. ISBN 8-0247-9009-2 

[2] VIRIUS, M. Programovací jazyky C/C++. Praha: Gcomp, 1992. ISBN 8-0901-0735-4. 

[3] PRATA, S. Mistrovství v C++. Praha: Computer Press, 2001. ISBN 8-0722-6339-0 

[4] KADLEC, V. Učíme se programovat v Borland C++ Builder a jazyce C++. Praha: 

Computer Press, 2001. ISBN 8-0722-6550-4 

[5] HOLAN, T., NERUDA, R. C++ Builder v příkladech. Praha: BEN, 2002. ISBN 8-0730- 

0042-3 

[6] HEROUT, P. Učebnice jazyka C. České Budějovice: Kopp, 1992. ISBN 8-0858-2821-9 

[7] HEROUT, P. Učebnice jazyka C, 2.díl. Č. Budějovice: Kopp, 1992. ISBN 80-85828-50-2 

[8] Virius,M.a kol. Jazyky C a C++ podle normy ANSI/ISO. GRADA, 1999. ISBN 80-7169- 

631-5 

[9] Schildt,H. Nauč se sám C++. Softpress, 2001. ISBN 80-86497-13-5 

str. 60

SeminÃ¡Å C++ - UTEE - VysokÃ© uÄenÃ­ technickÃ© v BrnÄ

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?

SeminÃ¡Å C++ - UTEE - VysokÃ© uÄenÃ technickÃ© v BrnÄ