Programování v jazyce C

{
#inclu
ude
de <s
<stdi
tdio
td
io.h
h>
/*
* Imp
m po
or
rt m
ma
ate
em
ma
at
ti
ické
ic
ého hl
hlav
vič
ičk
ko
o vé h
#i
inc
clu
lude <m
<mat
at
a
th.h>
>
#inclu
#in
cl de <s
clu
cl
<s dio
<stdio
io
io.h
o.h>
.h
h>
h>
/*
/
* Defi
De
efi n
ni
ničn
ič
ční
čn
ní
í i
in
inici
nici
ic
ci
c
iali
i
int
t m ai
ain()
()
flo
fl
oat
at pi
pi = 3
3.1
3.
. 415
15
5f
f;
;
{
/* Defi
/*
efin
ni
ic
ce lo
loká
oká
káln
l
ntí
íc
cmma
ch
h
p(r
prom
oměn
mě ný
nýc
ch
int
i
nt
main(
ain
in(
npr
n(
n()
) om
{
int A
A_x, A_
A _ y, B
B_x
_x
_x,
x, B_
B_ y;
y;
un
nsi
ns
ig
gn
g
ne
ed
int pol
int
/ Defi
/*
efinice lokáln
kál
ká
ln
ní uns
p
pr
rign
om
o
m
ědn né,
do
p
print
print
in
ntf(
nt
f(”Zadejte p
f(”
doub
ble vzd
zdal
alen
nos
ost
tB
Bod
odu;
u;
scanf
scanf(”%d”, &pol
lo
/* Inicial
al
liza
izac
iz
ace lo
ace
lokprintf(
promě
ě
pálních
printf(”
”Obvod
kru
uh
uh
return
0;
A_x = 2; A_y = 5;
}
B_x = 10; B_y = 17;
/* Vypočtení vzdálenosti
no
no
mezi d
}
Programování
v jazyce C
Ján Hanák
Nakladatelství a vydavatelství
w w w. co m p u t e r m e d i a . c z
R
Obsah
Obsah
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Úvod ........................................................................................................................................ 6
1. Definice základních termínů ................................................................................................ 8
2. Klasifikace programovacích jazyků .................................................................................... 9
3. Základní paradigmata programování ................................................................................ 10
4. Historie programovacích jazyků C, C++ a C++/CLI ........................................................... 12
5. Spuštění Visual C++ 2010 Express a založení prvního projektu jazyka C
ve vývojovém prostředí .................................................................................................... 22
5.1. Instalace produktu Visual C++ 2010 Express a první dotek s vývojovým prostředím .................................. 22
5.2. Visual C++ 2010 Express, programovací jazyky a vývoj softwaru ........................................................................ 24
5.3. Založení prvního projektu jazyka C .............................................................................................................................. 25
5.4. Zdrojový kód prvního programu v jazyce C ........................................................................................................... 29
6. Sestavení programu jazyka C .......................................................................................... 32
7. Spuštění programu jazyka C a charakteristika exekučních modelů
jedno- a vícevláknových programů jazyka C ................................................................... 34
7.1. Exekuční modely jedno- a vícevláknových programů ............................................................................................ 39
8. Základní řídící konstrukce strukturovaného programování ............................................ 42
9. Program = data + algoritmy .............................................................................................. 45
9.1. Konstrukce algoritmu pro vypočtení kořenů kvadratické rovnice .................................................................... 46
9.2. Konstrukce algoritmu pro zjištění hmotnostního indexu BMI osoby ................................................................. 47
9.3. Konstrukce algoritmu grafické transformace pro invertování bitové mapy .................................................... 48
9.4. Konstrukce algoritmu pro šifrování otevřeného textu pomocí Cézarovy šifry ......................................... 50
10. Vlastnosti algoritmů ...................................................................................................... 51
11. Výpočetní složitost algoritmů ......................................................................................... 55
11.1. Matematická definice O-notace ................................................................................................................................. 58
11.2. Matematická definice
11.3. Matematická definice
Ω-notace
Θ-notace
................................................................................................................................. 58
................................................................................................................................. 59
12. Prostředky pro reprezentaci algoritmů ............................................................................ 63
13. Datové typy ..................................................................................................................... 71
14. Definice proměnných ...................................................................................................... 75
14.1. Agregovaná definice více proměnných v jednom definičním příkazu .......................................................... 79
15. Přiřazovací příkaz ........................................................................................................... 80
15.1. Definiční inicializace proměnných .............................................................................................................................. 82
15.2. Agregovaná definiční inicializace více proměnných v jednom příkazu .................................................... 83
15.3. Vícenásobné přiřazení .................................................................................................................................................... 85
16. Praktické cvičení: program pro výpočet hmotnostního indexu BMI ............................. 86
3
Programování v jaz yce C
17. Číselné soustavy ............................................................................................................. 92
17.1. Desítková (decimální) číselná soustava ..................................................................................................................... 92
17.2. Osmičková (oktálová) číselná soustava ..................................................................................................................... 92
17.3. Šestnáctková (hexadecimální) číselná soustava .................................................................................................. 93
17.4. Dvojková (binární) číselná soustava .......................................................................................................................... 94
18. Konstanty ......................................................................................................................... 95
18.1. Celočíselné konstanty ...................................................................................................................................................... 95
18.2. Reálné konstanty ................................................................................................................................................................. 95
18.3. Znakové konstanty ............................................................................................................................................................. 97
18.4. Řetězcové konstanty ........................................................................................................................................................... 98
19. Praktické cvičení: program pro vypočtení vzdálenosti mezi dvěma body v rovině ......... 99
20. Globální proměnné .......................................................................................................... 101
21. Konstantní proměnné ..................................................................................................... 104
22. Direktiva preprocesoru #define a definice symbolických konstant .............................. 106
23. Typové konverze ............................................................................................................ 108
23.1. Implicitní typové konverze ........................................................................................................................................... 108
23.2. Explicitní typové konverze ........................................................................................................................................... 110
24. Alokační kapacita proměnných .................................................................................... 113
25. Operátory ....................................................................................................................... 115
25.1. Aritmetické operátory ..................................................................................................................................................... 117
25.2. Operátory pro inkrementaci a dekrementaci ........................................................................................................ 121
25.3. Logické operátory ............................................................................................................................................................ 123
25.4. Relační operátory ............................................................................................................................................................. 124
25.5. Přiřazovací operátory ..................................................................................................................................................... 125
25.6. Bitové operátory ................................................................................................................................................................ 126
25.7. Operátory bitového posunu ....................................................................................................................................... 127
26. Priorita a asociativita operátorů .................................................................................... 130
27. Rozhodovací příkazy ...................................................................................................... 133
27.1. Rozhodovací příkaz if ..................................................................................................................................................... 134
27.2. Rozhodovací příkaz if-else ........................................................................................................................................... 135
27.3. Rozhodovací příkaz if-else if… .................................................................................................................................... 138
27.4. Rozhodovací příkaz if-else if-else ............................................................................................................................... 139
27.5. Praktické cvičení: program na detekci kolize mezi automobilem a chodcem ............................................ 141
27.6. Rozhodovací příkaz switch ......................................................................................................................................... 143
27.7. Dvojcestné rozhodování pomocí ternárního operátoru (?:) ................................................................................ 146
28. Programové cykly ........................................................................................................... 148
28.1. Cyklus for ............................................................................................................................................................................. 148
4
Nadpis kapitoly
28.2. Cyklus while ...................................................................................................................................................................... 153
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
28.3. Cyklus do-while ............................................................................................................................................................... 155
29. Funkce ............................................................................................................................ 157
29.1. Praktické cvičení: programy s funkcemi pro přesný a aproximovaný výpočet n! ....................................... 163
29.2. Funkce a statické lokální proměnné ........................................................................................................................ 166
30. Struktury ........................................................................................................................ 169
30.1. Deklarace struktury ........................................................................................................................................................ 171
30.2. Instanciace struktury ....................................................................................................................................................... 172
30.3. Inicializace instance struktury ................................................................................................................................. 173
30.4. Použití inicializované instance struktury .............................................................................................................. 175
30.5. Alokační kapacita instance struktury ...................................................................................................................... 178
31. Pole ................................................................................................................................. 180
31.1. Praktické cvičení: program na vyhledání minimální a maximální hodnoty v jednorozměrném
automatickém poli ........................................................................................................................................................... 185
31.2. Kopírování jednorozměrného automatického pole ............................................................................................... 187
31.3. Alokační kapacita jednorozměrného automatického pole ............................................................................... 188
31.4. Jednorozměrné automatické pole instancí struktur ............................................................................................. 190
31.5. Dvojrozměrné automatické pole .............................................................................................................................. 191
32. Ukazatele ....................................................................................................................... 197
32.1. Získání hodnoty ukazatele ............................................................................................................................................ 202
32.2. Přiřazování ukazatelů ..................................................................................................................................................... 203
33. Pokročilá práce s funkcemi .......................................................................................... 205
33.1. Mechanismy předávání argumentů parametrickým funkcím ................................................................... 205
33.2. Rekurze a rekurzivní funkce .................................................................................................................................... 208
33.3. Funkce a pole .................................................................................................................................................................. 210
33.4. Funkce a instance struktur ........................................................................................................................................... 212
Závěr .................................................................................................................................... 214
O autorovi ........................................................................................................................... 214
5
Programování v jaz yce C
3.
Základní paradigmata
programování
Za poslední desetiletí se v informatice vyvinula tři základní paradigmata programování:
1. Strukturované (procedurální) programování.
Popis: Program je množinou funkcí (někdy též označovaných jako podprogramy),
které implementují parciální algoritmy, jež řeší delegované úlohy.
Vizualizace:
Obr. 1: Grafi cký model strukturovaného programu
10
3. Základní paradigmata programování
2. Objektově orientované programování (OOP).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Popis: Program je kolekcí diskrétních virtuálních objektů. Virtuální objekt je
abstraktním modelem reálného objektu skutečného světa, přičemž v sobě zapouzdřuje
data a metody. Objekty mezi sebou komunikují prostřednictvím zpráv.
Vizualizace:
Obr. 2: Grafi cký model objektově orientovaného programu
3. Komponentové programování.
Popis: Program je sadou komponent. Komponenta je softwarová součástka, která
disponuje vyšší úrovní abstrakce a zavádí pokročilou funkcionalitu. Interně je každá
komponenta složena z konečné a neprázdné množiny objektů, které mezi sebou vedou
informačně prospěšný dialog.
Vizualizace:
Obr. 3: Grafi cký model komponentového programu
11
7. Spuštění programu jazyka C
7.1.
Exekuční modely jedno- a vícevláknových programů
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Jedno- a vícevláknové programy se liší svými exekučními modely. Exekuční model neboli
model zpracování programu nám umožňuje zkoumat, jak budou prováděny algoritmy,
jež program implementuje. Teorie programování rozlišuje následující exekuční modely
jedno- a vícevláknových programů:
1. Sekvenční exekuční model. Sekvenční exekuční model je typický pro jednovláknové
programy. Jak jsme již zmínili, jednovláknový program realizuje zpracování algoritmů
sekvenčně, tedy na sériové bázi. Bez ohledu na to, na jak výkonném počítačovém
systému jednovláknový program spustíme, program bude obsazovat pouze jedno
z dostupných výpočetních jader procesoru. Na jednojádrovém procesoru je takovéto
rozvržení pochopitelné. Pokud ovšem máme vícejádrový procesor, tak zjišťujeme, že
jednovláknový program se sekvenčním exekučním modelem není schopen využít
všechnu výpočetní kapacitu takto dimenzovaného procesoru. Při 4jádrovém procesoru
budou tři výpočetní jádra nevyužita, a to samozřejmě není to, co bychom chtěli.
V informatice a v programování obecně je naším cílem vytvářet takové programy, které
se dovedou přizpůsobit jakékoliv hardwarové platformě a umí z ní vytěžit maximální
porci výkonu.
Obr. 14: Vizualizace sekvenčního exekučního modelu
2. Pseudoparalelní exekuční model. Pseudoparalelní exekuční model se vztahuje
k vícevláknovým programům. Jelikož se nechceme pouštět do rigorózních vědeckých
analýz, přijmeme domluvu, podle níž budeme říkat, že vícevláknové programy jsou
zpracovávány pseudoparalelně tehdy, pokud běží na počítačovém systému, jenž
obsahuje jeden jednojádrový procesor. Když je něco „pseudo“, tak se to tváří jinak, než
jak to ve skutečnosti je. Pseudoparalelní zpracování tedy není skutečně paralelní, jenom
z vnějšku, z pohledu vnějšího pozorovatele se zdá, že paralelní je. Pseudoparalelní
zpracování vícevláknového programu na jednoprocesorovém systému probíhá
iterativním preemptivním stylem, v němž procesor střídavě provádí instrukce všech
programových vláken.
39
Programování v jaz yce C
8.
Základní řídící konstrukce
strukturovaného programování
Kterýkoliv strukturovaný program můžeme vytvořit pouze s třemi základními řídícími
konstrukcemi, jimiž jsou sekvence, selekce a iterace.
Sekvence znamená postupné zpracování lineární posloupnosti programových příkazů. Tyto
příkazy jsou realizovány sekvenčně, tedy jeden za druhým, a to v takovém pořadí, v jakém
jsou zapsány ve zdrojovém kódu programu.
Obr. 18: Sekvence
Na obr. 18 vidíme sekvenční zpracování třech programových příkazů P1, P2 a P3. Nejprve je
zpracován příkaz P1, poté příkaz P2 a nakonec příkaz P3.
Selekce je základní rozhodovací konstrukce. Na základě rozhodovacího výrazu může program
přijmout v určitém čase rozhodnutí o tom, jaký bude jeho další průběh. Když je v programu
diagnostikována rozhodovací řídící konstrukce, existuje více variant dalšího toku programu.
Říkáme, že program se větví. Větvení programu představuje existenci konečné a neprázdné
množiny cest, jimiž se smí zpracování programu ubírat. Selekce je vždy jednoznačná
a deterministická. To se projevuje v tom, že program si po přijetí rozhodnutí (tedy po vyhodnocení
rozhodovacího výrazu) vybere právě jednu z možných větví a tou bude pokračovat dál.
Obr. 19: Selekce se dvěma větvemi (dvojcestné rozhodování)
42
10. Vlastnosti algoritmů
10. Vlastnosti algoritmů
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Na předchozích řádcích jsme nadnesli zjednodušenou definici algoritmu, podle níž jsme za
algoritmus považovali jakýkoliv postup složený z konečného počtu kroků, který nás dovede
k určitým výsledkům. Ve skutečnosti jsou však na algoritmy kladeny mnohem rigoróznější
požadavky, které zřetelně definují, jaké vlastnosti musí algoritmus mít. Za algoritmus je
obecně považován pouze takový postup, který splňuje následující kritéria:
1. Všeobecnost. Algoritmus je předpis, který vede k řešení všeobecné kategorie neboli
třídy úloh (problémových oblastí). Kupříkladu algoritmus pro řešení kvadratické
rovnice se dá použít pro nalezení kořenů jakékoliv rovnice, která disponuje
kvadratickým, lineárním a absolutním členem. Totéž lze konstatovat o algoritmu pro
výpočet indexu BMI. Pomocí zmíněného algoritmu je možné vypočítat hmotnostní
index jakéhokoliv člověka, autora této knihy či ctěného čtenáře nevyjímaje. Algoritmy
tedy mají generickou povahu, mění se pouze vstupní data a vypočtené výsledky.
2. Jednoznačnost. Každý algoritmus musí být jednoznačný, což znamená, že v kterémkoliv
jeho kroku musí být jasně předepsáno, jak se bude postupovat dál. Není jednoduše
možné, abychom měli algoritmus, který si v jistém okamžiku nebude „vědět rady“
s dalším postupem. Algoritmická jednoznačnost znamená, že algoritmus se musí za
každých okolností umět rozhodnout, jakou činnost vykoná v příštím kroku. Definice
algoritmu z hlediska jednoznačnosti musí být absolutně přesná: algoritmus nesmí zůstat
na pochybách ani tehdy, když před ním vyvstane několik variant dalšího postupu.
Oba uváděné algoritmy jsou jednoznačné. Kupříkladu když vypočteme hodnotu
diskriminantu, dovedeme určit, zda bude množina kořenů kvadratické rovnice prázdná,
či nikoliv. Stejně tak nám nečiní potíže vynést soud o hmotnosti osoby, když jsme pomocí
vzorečku vypočetli její hmotnostní index.
3. Konečnost. Za algoritmus je dle definice považován pouze takový postup, který je
složen z konečného počtu elementárních kroků. Těch kroků, které musí algoritmus
provést v zájmu dosažení výsledku, může být třeba 10, 100 nebo milion, ale vždy se
musí jednat o konečnou cifru. Postup, který se nedovede k výsledku dopracovat po
absolvování konečného počtu kroků, nemůžeme nazývat algoritmem. Například nelze
sestrojit algoritmus pro výpočet součtu všech přirozených čísel, poněvadž těchto čísel
je nekonečné množství. Oba naše ukázkové algoritmy jsou konečné, neboť k jejich
realizaci si vystačíme s několika málo úkony.
4. Rezultativnost. Rezultativnost je velice důležitá vlastnost algoritmu, která praví
toto: Po realizaci konečného počtu kroků nás musí algoritmus dovést k finálnímu
výsledku. Definice tedy jednoznačně stanovuje, že postup daný algoritmem musí
vyústit do jistého řešení zkoumaného problému. Jakkoliv efektivní a promyšlený může
algoritmus být, jestliže nás nedovede ke kýženému výsledku, je nám naprosto k ničemu.
Jinými slovy, na co by nám byl takový algoritmus vyřešení kvadratické rovnice, který by
51
Programování v jaz yce C
11.1. Matematická definice O-notace
Ať f(n) a g(n) jsou dvě nezáporné funkce definované na množině přirozených čísel (N).
Říkáme, že f(n) je velké O od funkce g(n), a zapisujeme f(n)=O(g(n)) nebo též f(n) ∈ O(g(n)),
jestliže existuje přirozené číslo n0 a konstanta c>0 takové, že pro každé n ≥ n0 platí f(n) ≤ c × g(n).
Ve zkratce lze O-notaci definovat takto:
f(n)∈O(g(n) ) ⇔ ∃ c >0,∃ n 0>0: ∀n ≥ n 0 : f(n) ≤ c × g(n)
Pokud je f(n)=O(g(n)), můžeme prohlásit, že řád funkce f(n) je menší nebo nanejvýš rovný
řádu funkce g(n). O(g(n)) proto slouží jako horní odhad složitosti funkce f(n). O naší funkci
T(n)=an 2 + bn + c tak povíme, že její asymptotická časová složitost je v O(n 2 ). Méně formálně:
můžeme identifikovat takovou kladnou konstantu c, že počínaje nějakým číslem n0 bude
graf funkce f(n) ležet vždy „pod“ grafem funkce c × g(n). Tuto situaci znázorňuje obr. 26.
Obr. 26: Vizualizace horního odhadu asymptotické časové složitosti algoritmu pomocí
O-notace
Pro informatiky je nejdůležitější O-notace, protože jim dává garanci horního odhadu
asymptotické časové složitosti algoritmu. Pomaleji, než udává O-notace, algoritmus už
nepoběží. Kromě O-notace, která slouží k vyjádření horní meze časové složitosti algoritmu,
jsou však zajímavé také další odhady, a sice odhad dolní a průměrné složitosti. Pro
asymptotické dolní ohraničení složitosti algoritmu se používá Ω-notace (Ω je Omega) a pro
asymptotické průměrné ohraničení složitosti algoritmu se zase aplikuje Θ-notace (Θje Théta).
11.2. Matematická definice Ω-notace
Ať f(n) a g(n) jsou dvě nezáporné funkce definované na množině přirozených čísel (N).
Říkáme, že f(n) je Ω od funkce g(n), a zapisujeme f(n)=Ω(g(n)) nebo též f(n)∈Ω(g(n)),
jestliže existuje přirozené číslo n0 a konstanta c>0 takové, že pro každé n ≥n0 platí
f(n) ≥ c × g(n).
58
11. Výpočetní složitost algoritmů
Ve zkratce lze Ω-notaci definovat takto:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
f(n)∈Ω(g(n) ) ⇔ ∃ c >0,∃ n 0>0: ∀n ≥ n 0 : f(n) ≥ c × g(n)
Obr. 27: Vizualizace dolního odhadu asymptotické časové složitosti algoritmu pomocí Ω -notace
11.3. Matematická definice Θ-notace
Ať f(n) a g(n) jsou dvě nezáporné funkce definované na množině přirozených čísel (N).
Říkáme, že f(n) je Θ od funkce g(n), a zapisujeme f(n)=Θ(g(n)) nebo též f(n) ∈ Θg(n)),
právě tehdy, když současně platí f(n)=O(g(n)) a f(n)=Ω(g(n)). Přesněji lze definici Θ-notace
přepsat pomocí přirozených konstant c1 a c 2 následujícím způsobem:
f(n)∈ Θ(g(n) ) ⇔ ∃ c1,c2>0, ∃n 0>0: ∀n ≥ n 0 : c1 × g(n) ≤ f(n) ≤ c2 × g(n)
Při použití Θ-notace se zkoumá asymptotické oboustranné omezení funkce f(n).
Obr. 28: Vizualizace průměrného odhadu asymptotické časové složitosti algoritmu pomocí
Θ-notace
59
14. Definice proměnných
14. Definice proměnných
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Proměnné vytváříme v jazyce C pomocí definičního příkazu, jehož všeobecná podoba
vypadá takto:
DatovyTyp IdentifikatorPromenne;
Příkaz, který zavádí do programu novou proměnnou, se skládá ze tří částí:
1. Datový typ. Každá proměnná musí disponovat svým datovým typem. To je důležité hned
ze dvou důvodů. Zaprvé, již od okamžiku vytvoření proměnné musí být jasné, jaký typ
dat neboli hodnot může být do dotyčné proměnné ukládán. Zadruhé, překladač musí
poznat datový typ proměnné, aby pro ni mohl alokovat dostatečně rozsáhlý paměťový
prostor. V této souvislosti je zapotřebí poznamenat, že v definičním příkazu existuje
mezi datovým typem a proměnnou relace 1:1. Jinými slovy, proměnná je spojena vždy
s právě jedním datovým typem. Není jednoduše možné, abychom proměnné přisoudili
dva datové typy, neboť to bychom uvedli překladač do nesnází (ten by ovšem kontroval
generováním chybového hlášení). Jako datový typ proměnné může posloužit kterýkoliv
z primitivních nebo uživatelsky deklarovaných datových typů.
2. Identifikátor proměnné. Identifikátor proměnné čili název proměnné představuje
uživatelsky přívětivé pojmenovávání, které může programátor proměnné přiřadit.
V jazyce C platí pro názvosloví proměnných jisté pojmenovací konvence. Povězme si
tedy, na co bychom si měli při pojmenovávání proměnných dát pozor:
• Název proměnné nesmí obsahovat mezery.
• Název proměnné nesmí začínat číslicí.
• Název proměnné nesmí být totožný s klíčovým slovem nebo spojením klíčových
slov jazyka C.
• Název proměnné se nesmí shodovat s názvem jiné proměnné, která byla ve zdrojovém
kódu jazyka C již dříve definována.
Nejčastější chybou u začínajících programátorů je snaha složit název proměnné z více
slov, které podle intuice oddělují mezerami. Pro mezeru v identifikátoru proměnné
ovšem není místo. Pokud se nelze vyhnout víceslovnému názvu, máme na výběr
z několika alternativ:
• Jednotlivá slova v názvu proměnné budeme separovat symbolem podtržení (_).
Proměnná se tedy může jmenovat třeba Moje_Mala_Promenna nebo také
moje_mala_promenna.
• V praxi se často uplatňuje velbloudí notace, podle níž se slova ve víceslovném názvu
nijak neoddělují a první slovo je psáno s malým začátečním písmenem. Všechna
další slova jsou však již psána s velkými začátečními písmeny. Název dřívější
proměnné se tak použitím velbloudí notace změní na mojeMalaPromenna.
75
Programování v jaz yce C
16. Praktické cvičení: program pro
výpočet hmotnostního indexu BMI
Vyzbrojeni základními znalostmi o proměnných, přiřazovacích příkazech, operátorech
a operandech se můžeme směle pokusit o zkonstruování složitějšího programu. Co takhle
program pro výpočet hmotnostního indexu BMI? Děkujeme pěkně, sem s ním.
#include <stdio.h>
int main()
{
int hmotnost = 70;
float vyska = 1.77, indexBMI;
indexBMI = hmotnost / (vyska * vyska);
printf(”Index BMI osoby, ktera meri %f m ”
”a vazi %d kg je %f.”, vyska, hmotnost, indexBMI);
return 0;
}
Komentář k zdrojovému kódu jazyka C: První 2 příkazy v těle hlavní funkce main
zakládají 3 lokální proměnné (hmotnost, vyska a indexBMI), přičemž dvě z nich rovněž
explicitně inicializují. Program předpokládá, že hmotnost uživatele bude zadána jako
celé číslo, a proto lokální proměnné hmotnost při její definici přisuzuje datový typ int.
Lokální proměnná vyska je typu float – i to je v pořádku, poněvadž matematický vzorec
pro výpočet hmotnostního indexu počítá s tím, že výška osoby bude zadána v desetinné
podobě (jde o výšku v metrech). Lokální proměnná indexBMI je rovněž typu float, neboť
výsledný hmotnostní index bude mít podobu reálné hodnoty. Na celém programu je
patrně nejsložitější přiřazovací příkaz, jenž provádí inicializaci proměnné indexBMI:
indexBMI = hmotnost / (vyska * vyska);
Dobrá, v tomto momentě nás nejvíc zajímá, jak bude probíhat inicializace proměnné
indexBMI, není-liž pravda? Nejprve musíme určit hodnotu aritmetického výrazu, jenž
se rozprostírá na pravé straně od operátoru =. Zdejší výraz je bezesporu složitější než ten,
o němž jsme již psali. Jestliže se ptáte proč, máme pro vás tyto důvody:
1. V aritmetickém výrazu se nacházejí dva operátory:
1. Operátor / (lomítko) uskutečňující operaci dělení.
2. Operátor * (hvězdička) provádějící operaci násobení.
2. Aritmetické operátory / a * mají stejnou prioritu. Jelikož index BMI vypočítáme tak,
že hmotnost osoby vydělíme druhou mocninou její výšky, musíme nejprve vypočítat
tuto druhou mocninu. Operace násobení tak musí být vykonána jako první, proto její
prioritu zvyšujeme použitím závorek.
86
16. Praktické cvičení
Závorky zde plní stejnou roli jako v běžné matematice: nařizují, která operace má být
uskutečněna dřív. Užití závorek v uvedeném aritmetickém výrazu je velice důležité,
poněvadž bez jejich asistence by program počítal nesprávné hodnoty hmotnostních indexů.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Překladač bude při vyhodnocení aritmetického výrazu postupovat tak, jak znázorňuje
následující model (operace, které jsou v jednotlivých krocích modelu realizovány, jsou
vyznačeny šedou podkladovou barvou):
1. Zjistí aktuální hodnotu lokální proměnné vyska:
indexBMI = hmotnost / (vyska
vyska * vyska);
vyska
2. Vypočte druhou mocninu aktuální hodnoty lokální proměnné vyska:
indexBMI = hmotnost / (vyska
vyska * vyska
vyska);
3. Aktuální hodnotu lokální proměnné hmotnost vydělí hodnotou součinu, jenž byl
zjištěn v předcházejícím kroku tohoto modelu:
indexBMI = hmotnost / (vyska * vyska)
vyska);
4. Vypočtenou hodnotu hmotnostního indexu přiřadí do lokální proměnné
indexBMI:
indexBMI = hmotnost / (vyska * vyska)
vyska);
Když program sestavíme, překladač zahlásí jedno varování, které se pojí s řádkem, v němž
je definována lokální proměnná vyska:
float vyska = 1.77, indexBMI;
Jak se dozvíme v jedné z příštích kapitol této publikace, samostatně stojící (diskrétní) číselné
hodnoty, jako je 1.77 v našem zdrojovém kódu, jsou považovány za číselné konstanty.
Konstanta 1.77 je reálnou konstantou, které překladač implicitně přisoudí datový typ
double. Když se podíváme na fragment zdrojového kódu, tak zjistíme, že se snažíme reálnou
konstantu 1.77 typu double přiřadit do lokální proměnné vyska, jejímž typem je float. Tuto
přiřazovací operaci ovšem nelze provést přímo, protože se liší datové typy entit po obou
stranách přiřazovacího operátoru (float ↔ double). Aby překladač vyřešil vzniklou situaci,
automaticky změní datový typ reálné konstanty 1.77 z double na float, čímž problém spojený
s nesouladem datových typů rázem zmizí. Operace, kterou překladač právě provedl, se
v programování označuje termínem implicitní typová konverze. Ačkoliv změna datového
typu reálné konstanty nebude mít v našem případě žádný negativní dopad, ne vždy je
tomu tak. Musíme si totiž uvědomit, že překladač implicitně převádí hodnotu přesnějšího
typu double na hodnotu méně přesného typu float. Takováto typová konverze může
být poznačena ztrátou dat. A právě z tohoto důvodu generuje překladač varování. I když
totiž překladač typovou konverzi zpracuje ve své vlastní režii, emituje varování, které má
programátora upozornit na fakt uskutečnění implicitní typové konverze, která může mít
potenciálně nebezpečné implikace.
87
Programování v jaz yce C
17. Číselné soustavy
17.1. Desítková (decimální) číselná soustava
Jakoukoliv hodnotu desítkové soustavy můžeme zapsat v podobě součtu mocnin čísla 10.
Uvažujme například o číslu 1253:
(1253)10=1×1000+2×100+5×10+3×1
(1253)10=1×103+2×102+5×101+3×100
Poznámka: Při pojednání o reprezentaci čísel v různých pozičních číselných soustavách platí
konvence, že samotná číselná hodnota je zapsána v závorkách a základ číselné soustavy, v níž je hodnota
udána, je umístěn v dolním indexu. Tuto konvenci budeme na stránkách naší knihy dodržovat, neboť
je nejenom efektivní, nýbrž také dobře vizuálně čitelná. Pokaždé, když se podíváte na dolní index
dotyčné číselné hodnoty, budete okamžitě vědět, v jaké soustavě je tato hodnota interpretována.
Desítková soustava používá pro vyjádření číselných hodnot deset číslic: 0, 1, 2, 3, 4, 5, 6, 7, 8 a 9.
17.2. Osmičková (oktálová) číselná soustava
Osmičková soustava pracuje s mocninami čísla 8, přičemž libovolná hodnota je v této
číselné soustavě vyjádřena posloupností cifer z intervalu <0, 7>.
(6203)8=6×83+2×82+0×81+3×80
Pro převedení osmičkové konstanty 6203 do desítkové soustavy rozvineme mocniny čísla
8 a vypočteme celý součet, poté obdržíme ekvivalent čísla 6203 v desítkové soustavě.
(6203)8=6×512+2×64+0×8+3×1
(6203)8=3072+128+0+3
(6203)8=(3203)10
Jak je vidět, dospěli jsme k závěru, že osmičkové hodnotě 6203 připadá číslo 3203 v desítkové
číselné soustavě. Čtenáři se zvídavější povahou mohou v této chvíli namítnout, zda jsme
s to nabídnout důkaz o zpětné konverzi. Jednoduše řečeno, jak dokážeme, že číslo 3203
v desítkové soustavě je doopravdy protějškem čísla 6203 v osmičkové soustavě? Důkaz
o této skutečnosti podáme tak, že desítkovou číselnou hodnotu budeme neustále dělit osmi,
přičemž si vždycky poznačíme zbytek po dělení. Matematický algoritmus, jenž charakterizuje
tento proces, uvádí tab. 2.
Tab. 2: Algoritmus pro převod celočíselné hodnoty z desítkové do osmičkové číselné soustavy
92
Pořadí operací
Podíl
Zbytek po dělení
3203 : 8
400
3
400 : 8
50
0
50 : 8
6
2
6:8
0
6
20. Globální proměnné
20. Globální proměnné
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Proměnné se v programování dělí na dvě základné skupiny: lokální proměnné a globální
proměnné. Klasifikačním kritériem pro zařazení proměnné do jedné z uvedených skupin
je její oblast platnosti. Lokální proměnné, s nimiž jsme prozatím intenzivně pracovali,
se vážou na funkci, v níž jsou definovány. Všechny proměnné definované v hlavní
funkci main jsou lokální proměnné, protože jejich oblastí platnosti je tělo této funkce.
Lokální proměnné nelze přímo použít jinde, tedy mimo funkci, ve které jsou situovány
jejich definiční příkazy. Jestliže je nutno zvětšit programový blok, v rámci kterého bude
proměnná dosažitelná neboli viditelná, můžeme s výhodou využít globální proměnné.
Definiční příkaz zakládající globální proměnnou není umístěn v těle žádné funkce.
Ve skutečnosti se definice globální proměnné nachází „nad“ všemi přítomnými funkcemi.
Vzhledem k tomu, že stavbu uživatelsky definovaných funkcí budeme rozebírat až
později, v této kapitole se budeme soustředit pouze na zkoumání vztahu mezi globálními
proměnnými a hlavní funkcí main.
Definice globální proměnné se uskutečňuje přesně podle generického syntaktického
vzoru, který platí rovněž pro lokální proměnné. Každá globální proměnná musí být svůj
datový typ a identifikátor. Globální proměnné jsou překladačem jazyka C implicitně
inicializovány, což znamená, že v závislosti na svých datových typech vždy obdrží
určité výchozí inicializační hodnoty. Pro globální proměnné integrálních datových typů
je implicitní inicializační hodnotou celočíselná nula. Pro globální proměnné reálných
datových typů je implicitní inicializační hodnotou reálná nula. Pro globální proměnné
znakového datového typu char je implicitní inicializační hodnotou nulový znak.
Upozornění: Zatímco globální proměnné jsou překladačem jazyka C implicitně inicializovány,
pro lokální proměnné to neplatí. Jsme-li spokojeni s implicitní inicializační hodnotou globální
proměnné, můžeme tuto proměnnou okamžitě použít v kterémkoliv platném výrazu nebo
příkazu libovolné funkce, jež tvoří syntaktický skelet programu jazyka C. Definované, ovšem
explicitně neinicializované lokální proměnné nemohou být použity tímto způsobem, poněvadž
jejich inicializační hodnoty nejsou implicitně definovány. Lokální proměnné musejí být vždy
nejprve explicitně inicializovány a až poté se smí vyskytnout ve výrazech a příkazech jazyka C.
Následující program jazyka C demonstruje práci s globální proměnnou:
#include <stdio.h>
/* Definiční inicializace globální proměnné. */
float pi = 3.1415f;
int main()
{
unsigned int polomer;
printf(”Zadejte polomer kruhu (jako cele cislo): ”);
scanf(”%d”, &polomer);
printf(”Obvod kruhu s polomerem %d je %.2f.\n”, polomer, 2 * pi * polomer);
return 0;
}
101
Programování v jaz yce C
21. Konstantní proměnné
Proměnnou jsme definovali jako datový objekt, do kterého je možné ukládat hodnoty
určitého datového typu. Ukázali jsme si, jak se proměnné definují a jak se do nich přiřazují
hodnoty. Přitom jsme se vší důkladností pravili, že jakmile je proměnná na světě, můžeme
její hodnotu měnit tolikrát, kolikrát budeme chtít. Proměnná coby datový kontejner může
měnit svou hodnotu, to je fakt, který plyne již ze samotného názvu „proměnná“. Nyní
bychom se měli obeznámit s konstantními proměnnými, což jsou proměnné, jež nesmí po
svých prvotních inicializacích měnit své hodnoty.
Poznámka: V programovací hantýrce jsou konstantní proměnné velice často označovány za
konstanty. Nicméně takováto interpretace vede ke konfliktům s „opravdovými“ konstantami,
o nichž jsme mluvili v předcházejících podkapitolách této publikace. Abychom dodrželi jasnou
a přehlednou linii výkladu, budeme proměnné, jež nelze reinicializovat, nazývat konstantními
proměnnými.
Konstantní proměnné v jazyce C poznáme docela snadno, protože v jejich definičních
příkazech se vyskytuje modifikátor const:
const DatovyTyp IdentifikatorPromenne = InicializacniHodnota;
– nebo –
DatovyTyp const IdentifikatorPromenne = InicializacniHodnota;
Když se v definici proměnné objeví modifikátor const, máme jasný důkaz o tom, že se
jedná o konstantní proměnnou. Ze syntaktického hlediska se může modifikátor const
nacházet před specifikací datového typu konstantní proměnné, nebo až za ní.
Tip: Domníváme se, že lepším řešením je uvádět modifikátor const před datovým typem
konstantní proměnné, protože je tak okamžitě zřejmé, že manipulujeme s konstantní proměnnou.
Tato vizuální pomůcka nabývá na ceně zejména při práci s robustnějšími strukturovanými
programy.
Konstantní proměnná musí mít samozřejmě svůj identifikátor, v tomto ohledu se nijak
neodlišuje od běžné čili nekonstantní proměnné.
Jistě si vzpomínáte na program pro výpočet obvodu kruhu. V tomto programu jsme
definovali globální proměnnou pi, která uchovávala aproximovanou hodnotu čísla π.
Vzhledem k tomu, že hodnota této reálné konstanty se nikdy nebude měnit, jako logický
nám přijde návrh přetvořit globální proměnnou na globální konstantní proměnnou.
104
25. Operátory
25. Operátory
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Přestože jsme se v uplynulých kapitolách seznámili s některými aritmetickými operátory,
jako jsou +, – či *, operátory mají v jazyce C, a potažmo v celém oboru programování,
tak silnou pozici, že by byla naprostá chyba, kdybychom jim v této publikaci nevěnovali
samostatnou kapitolu. Již víme, že operátory jsou symboly, které předepisují provedení
rozličných programových operací. Tak kupříkladu operátor + sčítá hodnoty, zatímco
operátor * je násobí. Rovněž jsme si řekli, že entity, s nimiž operátory pracují, se nazývají
operandy. Výraz jsme potom definovali jako smysluplnou posloupnost operandů
a operátorů, která produkuje hodnotu jistého datového typu. Ve výbavě jazyka C se
nachází celá hromada operátorů. Abychom se ve všech těch operátorech rychle neztratili,
rozdělíme je do homogenních skupin podle 2 elementárních klasifikačních kritérií. První
kritérium je funkční: jeho užitím budeme operátory třídit podle jejich funkce, tedy podle
druhu programových operací, které uskutečňují. Z funkčního hlediska jsou v jazyce C
k dispozici následující kategorie operátorů:
1. Aritmetické operátory
2. Operátory pro inkrementaci a dekrementaci
3. Logické operátory
4. Relační operátory
5. Přiřazovací operátory
6. Bitové operátory
7. Operátory bitového posunu
8. Speciální operátory
Na operátory ovšem nemusíme nahlížet pouze striktně ve vztahu k jejich funkci. Operátory
totiž můžeme klasifikovat také podle počtu operandů, s nimiž pracují. Tak dostáváme
mnohem užší, přesněji tříprvkovou, množinu operátorů přítomných v jazyce C:
1. Unární operátory – spolupracují s jedním operandem.
2. Binární operátory – spolupracují se dvěma operandy.
3. Ternární operátory – spolupracují se třemi operandy.
Pokud operátor ke své práci vyžaduje pouze jeden operand (například jednu proměnnou),
pak je to operátor unární. Označíme-li unární operátor symbolem α a operand symbolem
O, pak jejich vzájemný vztah můžeme zapsat takto:
αO
a v některých případech, u inkrementačních a dekrementačních operátorů, také takto:
Oα
α
115
25. Operátory
25.1. Aritmetické operátory
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Matematické operace patří k nejčastěji vykonávaným úkonům v programování. Provádění
základních aritmetických operací, jako jsou sčítání, odečítání, násobení a dělení, nám
umožňují následující aritmetické operátory:
•
•
•
•
•
operátor pro sčítání +,
operátor pro odečítání – ,
operátor pro násobení *,
operátor pro dělení /,
operátor pro zjištění zbytku po celočíselném dělení %.
Se čtveřicí operátorů +, –, * a / jsme se již setkali, takže víme, jak pracují. Všechno jsou
to vesměs binární operátory, které reflektují základní matematické operace prováděné
s operandy. Jako praktické cvičení pro zopakování základních aritmetických operátorů si
napíšeme program, který bude zobrazovat kalorickou hodnotu vybraného jídla. Prostudujme
následující fragment zdrojového kódu jazyka C:
#include <stdio.h>
int main()
{
int bilkoviny, cukry, tuky;
int energetickyObsah;
float denniPodil;
printf(”Zadejte, kolik gramu bilkovin obsahuje vase jidlo: ”);
scanf(”%d”, &bilkoviny);
printf(”Zadejte, kolik gramu cukru obsahuje vase jidlo: ”);
scanf(”%d”, &cukry);
printf(”Zadejte, kolik gramu tuku obsahuje vase jidlo: ”);
scanf(”%d”, &tuky);
energetickyObsah = (bilkoviny * 4) + (cukry * 4) + (tuky * 9);
denniPodil = ((float)energetickyObsah / 2000) * 100;
printf(”\nVase jidlo obsahuje %d kcal.”, energetickyObsah);
printf(”\nKonzumaci tohoto jidla jste pokryli %.2f %% z vaseho ”
”optimalniho \ndenniho energetickeho prijmu potravy.\n”, denniPodil);
return 0;
}
Komentář k zdrojovému kódu jazyka C: Náš program si nejprve od uživatele vyžádá
informace o jídle. Stěžejní je přitom množství (v gramech) spotřebovaných živin, jimiž
jsou bílkoviny, cukry a tuky. K úschově těchto hodnot definujeme tři celočíselné lokální
proměnné, jejichž názvy jsme zvolili tak, aby nám napovídaly, k čemu slouží. Vstupní data,
která obdržíme od uživatele, ukládáme do předem připravených lokálních proměnných.
Jakmile víme, kolik gramů bílkovin, cukrů a tuků spotřebované jídlo obsahuje, vypočteme
jeho energetickou hodnotu v kilokaloriích (kcal).
117
Programování v jaz yce C
26. Priorita a asociativita operátorů
Všechny operátory jazyka C mají svou prioritu. Priorita říká, v jakém pořadí budou
realizovány programové operace, které jsou předepsané jednotlivými operátory. Kdyby
nebyla stanovena přesná prioritní pravidla, tak by překladač nedovedl správně vyhodnocovat
programové výrazy.
Kupříkladu výraz a * b – c bude překladač vyhodnocovat jako (a * b) – c, poněvadž ze
zapsaných aritmetických operátorů má operátor součinu (*) vyšší prioritu než operátor rozdílu
(–). Jistě, zmíněný aritmetický výraz je triviální, neboť nám dovoluje přímo aplikovat pravidla,
která známe z matematiky. Ovšem věděli bychom, jak postupovat, kdyby bylo znění výrazu
takovéto: a * b % c? Modulo neboli operátor zbytku po celočíselném dělení (%) vypočte zbytek
po celočíselném dělení svých operandů a ten vrátí v podobě své návratové hodnoty. Otázkou
ale zůstává, zda bude překladač vyhodnocovat výraz a * b % c jako (a * b) c anebo jako
a * (b % c). Za předpokladu, že je výraz zapsán korektně, tak překladač musí vždy vědět, jak
určit jeho hodnotu. A to i za těch okolností, kdy se bude potýkat s vpravdě komplikovanými
výrazy.
Překladač se při své práci nejprve řídí prioritou operátorů. Podle priority smíme operátory
jazyka C kategorizovat do homogenních prioritních tříd, přičemž v každé prioritní třídě
se nacházejí operátory se stejnou prioritou. Například binární aritmetické operátory *, /
a % sdílejí stejnou prioritní třídu (označme ji pro lepší orientaci identifikátorem PT1), což
znamená, že disponují totožnou prioritou. Další binární aritmetické operátory + a – jsou
umístěny v jiné prioritní třídě (PT2) a opět sdílejí stejnou prioritu.
Prioritní třídy vytvářejí komplexní hierarchii. Přitom platí, že priorita operátorů patřících do
jednotlivých prioritních tříd klesá ve směru odshora dolů. Omezíme-li se na prioritní třídy
PT1 a PT2, pak můžeme konstatovat, že prioritní třída PT1 disponuje v celkové hierarchii
vyšší prioritou než prioritní třída PT2. Z toho samozřejmě plyne, že binární aritmetické
operátory *, / a % mají přednost před operátory + a –. Hierarchii prioritních tříd vybraných
operátorů jazyka C uvádíme v tab. 11.
Někdy se stává, že prioritní pravidla pro jednoznačné vyhodnocení výrazů nestačí. To se
děje tehdy, sejdou-li se v jednom výrazu (nebo podvýrazu) operátory se stejnou prioritou (čili
operátory z totožné prioritní třídy). Jak vidíme, v tomto kontextu jsou překladači pravidla pro
stanovení priority k ničemu, neboť pomocí nich nedovede přijmout kvalifikované rozhodnutí.
Proto potřebujeme další mechanismus, jenž bude schopen vzniklou nejednoznačnost
odstranit. Tímto mechanismem jsou asociativní pravidla, která nařizují, v jakém pořadí
budou prováděny operace předepsané operátory se stejnou prioritou.
Asociativita je vlastnost operátorů, podle níž dokáže překladač určit, zda se operátor váže (čili
asociuje) s levým nebo pravým operandem. Pořadí determinované asociativitou operátorů bude
vždy dáno dvěma směry: buď zleva doprava, nebo zprava doleva. Pro lepší názornost použijeme
směrové šipky: → pro operátory asociativní zleva doprava a ← pro operátory asociativní zprava
doleva. Tak třeba všechny binární aritmetické operátory jsou asociativní zleva doprava (→).
130
26. Priorita a asociativita operátorů
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Tab. 11: Hierarchie prioritních tříd vybraných operátorů jazyka C
Prioritní třída
Operátory
Asociativita
1.
() [] -> .
zleva doprava (→)
2.
! ~ ++ -- + - * & (Typ) sizeof
zprava doleva (←)
3.
*/%
zleva doprava (→)
4.
+-
zleva doprava (→)
5.
<< >>
zleva doprava (→)
6.
< <= > >=
zleva doprava (→)
7.
== !=
zleva doprava (→)
8.
&
zleva doprava (→)
9.
^
zleva doprava (→)
10.
|
zleva doprava (→)
11.
&&
zleva doprava (→)
12.
||
zleva doprava (→)
13.
?:
zprava doleva (←)
14.
= += -= *= /= %= &= ^= |= <<= >>=
zprava doleva (←)
15.
,
zleva doprava (→)
Vraťme se nyní k vyhodnocení výrazu a * b % c. Vzhledem k tomu, že operátory * a %
mají stejnou prioritu, musí si překladač pomoci jejich asociativitou. Ta má orientaci →, což
znamená, že výraz bude vyhodnocen jako (a * b) % c. Pokud předpokládáme následující
inicializaci proměnných: a = 50, b = 2 a c = 4, tak hodnotou výrazu bude 0 (100 % 4 = 0).
Přirozeně, ne všechny operátory jsou asociativní →, nemálo z nich má přesně opačnou
asociativitu. Jedním z takovýchto operátorů je přiřazovací operátor (=). Asociativitu operátoru
= jsme objevili již dávno a implicitně jsme s ní pracovali, aniž bychom ji nazvali příslušným
odborným termínem. Jednoduše řečeno, v příkazu p = V; , kde p je proměnná zvoleného
datového typu a V je výraz, bude vždy nejprve vyhodnocen výraz V a až poté bude hodnota
výrazu V přiřazena do proměnné p. Podotkněme, že v závislosti na datovém typu proměnné
a datovém typu hodnoty výrazu mohou (ovšem nemusí) být zpracovány implicitní typové
konverze. Rozvineme-li úvahy o asociativitě operátoru =, pak okamžitě vyřešíme i otázku
vícenásobného přiřazení. Příkaz m = n = o = p; bude vyhodnocen jako m = (n = (o = p));.
Tip: Pokud si nejsme jisti, jakou prioritu a asociativitu mají operátory v zapsaném výrazu, můžeme
si pomoci uzávorkováním těch částí výrazu (čili podvýrazů), které mají být provedeny před ostatními.
Vložíme-li podvýraz do závorek, zvyšujeme preferenci jeho zpracování. S prioritou tak ovlivňujeme
rovněž asociativitu operátorů. Jenom prosím nezapomínejme na skutečnost, že v kterémkoliv výrazu
musí být sudý počet závorek.
131
27. Rozhodovací příkazy
27. Rozhodovací příkazy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
S rozhodovacími problémy se v běžném životě setkáváme velice často. Přijetí jistého
rozhodnutí se odvíjí od charakteru rozhodovacího problému, vstupních dat a potenciálních
alternativ, jimiž se může naše rozhodování ubírat. Proces rozhodování lze graficky
znázornit pomocí rozhodovacího stromu. Na obr. 35 je znázorněn vývojový diagram
s rozhodovacím stromem, který řeší rozhodování o koupi nového auta.
Obr. 35: Vývojový diagram rozhodovacího stromu řešící rozhodování o zakoupení nového auta
Programovací jazyk C obsahuje sadu rozhodovacích příkazů, jejichž pomocí mohou vývojáři
realizovat programová rozhodnutí a větvit tak tok programu. Jde o následující příkazy:
• Příkaz if pro realizaci jednocestného rozhodování.
• Příkaz if-else pro realizaci dvojcestného rozhodování.
• Příkaz if-else if… pro realizaci vícecestného rozhodování.
• Příkaz if-else if-else pro realizaci vícecestného rozhodování.
• Příkaz switch pro realizaci vícecestného rozhodování.
• Ternární operátor ?: pro realizaci dvojcestného rozhodování.
Všechny zmíněné rozhodovací příkazy rozebereme v textu následujících podkapitol.
133
Programování v jaz yce C
27.1. Rozhodovací příkaz if
Rozhodovací příkaz if umožňuje větvení toku programu podle jednostranné podmínky.
Jeho generický syntaktický model vypadá takto:
if(PV)
P1;
– nebo –
if(PV)
{
P1; P2; ... Pn;
}
kde:
• PV je podmínkový výraz, jehož hodnotou bude buď logická pravda, nebo logická
nepravda.
• P1, P2, … Pn jsou příkazy jazyka C, jež budou zpracovány pokaždé, když bude hodnotou
PV logická pravda.
Rozhodování pomocí příkazu if se uskutečňuje takto:
1. Vyhodnotí se PV.
2. Jestliže je hodnotou PV logická pravda, tak se zpracují příkazy umístěné v těle větve if.
Pokud je v těle větve if situován právě jeden příkaz, není nutno explicitně vyznačovat
její tělo pomocí složených závorek. Naopak, nacházejí-li se v těle větve if alespoň dva
příkazy, musí být její tělo explicitně vyznačeno složenými závorkami.
3. Jestliže je hodnotou PV logická nepravda, tak rozhodování končí. Dochází k opuštění
rozhodovacího příkazu if a ke zpracování nejbližšího možného příkazu, jenž následuje
za rozhodovacím příkazem if.
Vizualizaci jednocestného rozhodování pomocí příkazu if můžeme vidět na obr. 36.
Jednocestné rozhodování nám sdělí, zda přirozené číslo, které zadal uživatel na vstupu, je sudé:
#include <stdio.h>
int main()
{
int cislo;
printf(”Zadejte prirozene cislo: ”);
scanf(”%d”, &cislo);
if(cislo % 2 == 0)
printf(”Bylo zadano sude cislo.\n”);
return 0;
}
134
27. Rozhodovací příkazy
Tento program nemá žádná kritická místa, jenom si musíme uvědomit, že sudé přirozené
číslo je každé číslo, jehož zbytek po dělení dvojkou je nulový.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Obr. 36: Pracovní model příkazu if
27.2. Rozhodovací příkaz if-else
Rozhodovací příkaz if-else uskutečňuje řízení toku programu podle oboustranné
podmínky. Jeho generický syntaktický model je následující:
if(PV)
P1;
else
R1;
– nebo –
if(PV)
{
P1; P2; ... Pn;
}
else
{
R1; R2; ... Rn;
}
kde:
• PV je podmínkový výraz, jehož logickou hodnotu lze určit.
• P1, P2, … Pn jsou příkazy, které budou provedeny tehdy, bude-li hodnotou PV logická pravda.
• R1, R2, … Rn jsou příkazy, jež budou zpracovány v případě, kdy bude hodnotou PV logická
nepravda.
135
27. Rozhodovací příkazy
27.5. Praktické cvičení: program na detekci kolize mezi
automobilem a chodcem
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Představme si tuto modelovou situaci: Automobil jede po cestě, když se v jisté vzdálenosti od
něj objeví chodec. Cílem našeho dalšího praktického cvičení je zjistit, zda mezi dopravním
prostředkem a člověkem dojde ke kolizi, či nikoliv. Budeme přitom postupovat následovně:
1. Celkovou vzdálenost, která dělí automobil od chodce, označíme identifikátorem SC.
Dodejme, že celková vzdálenost je dána dráhou, která dělí automobil a chodce v čase t0
čili v čase, kdy auto jede počáteční rychlostí v0 a řidič spatří chodce na cestě před sebou.
2. Při analýze pohybu automobilu rozdělíme celou dráhu na dvě menší dráhy: jedna
z nich bude reakční dráha (SR) a druhá bude brzdná dráha (SB). Reakční dráha je dráha,
kterou automobil urazí během reakčního času (tR), tedy času, jenž je vymezen časovým
intervalem, na jehož konci si řidič automobilu uvědomí, že v zájmu zabránění kolize
s objektem na cestě má sešlápnout brzdový pedál a snížit tak rychlost auta. Brzdná
dráha je pak dráha, která je nutná k úplnému zastavení vozidla. Jelikož počítáme
s úplným zabrzděním, konečná rychlost automobilu (vF) bude nulová.
3. Problém detekce kolize má fyzikální charakter, přičemž pro jeho vyřešení využijeme
několik matematických vztahů z mechaniky, jedné z disciplín moderní fyziky. Je zřejmé,
že ke kolizi nedojde v případě, že SR + SB < SC. Protože reakční dráhu ujede automobil
v počáteční rychlosti v0, můžeme ji vypočítat takto:
SR = v0 tR
4. Výpočet brzdné dráhy je o něco komplikovanější, neboť v něm musíme uvažovat se
zpomalením automobilu v důsledku aktivace brzdných mechanizmů. Všeobecný
vzorec pro výpočet brzdné dráhy má tuto podobu:
SB =
v F2- v 02
2a
kde:
• vF je konečná rychlost automobilu,
• v0 je počáteční rychlost automobilu,
• a je koeficient zpomalení.
Jelikož z našich předpokladů vyplývá, že vF = 0, tak samozřejmě i vF2 = 0. Všeobecný
vzorec pro stanovení brzdné dráhy proto smíme upravit následujícím způsobem:
SB =
- v 02
2a
141
Programování v jaz yce C
Ovšem co to ve skutečnosti znamená? Pomozme si praktickou ukázkou. Povězme,
že počáteční rychlost automobilu bude 60 km/h, celková vzdálenost (SC) bude 50 m,
reakční čas (tR) bude 0,45 s a koeficient zpomalení (a) bude -6,5 m/s2.
Poznámka: Ještě než začneme s dosazováním hodnot do vzorců, musíme unifikovat jednotky
všech veličin. Jelikož budeme chtít mít všechny veličiny zadány v metrech nebo v sekundách,
budeme muset počáteční rychlost auta převést z km/h na m/s. To znamená dělit rychlost
zadanou v km/h reálnou konstantou 3,6. Platí, že 60 km/h se přibližně rovná 16,67 m/s.
5. Reakční a brzdnou dráhu vypočítáme takto:
SR = 16,67 × 0,45 = 7,5 m
SB =
- 16,672
=
2×(- 6,5)
- 277,89
= 21,38 m
- 13
ST = SR + SB = 7,5 + 21,38 ≅ 29 m
V našem fyzikálním modelu tedy automobil zcela zastaví po ujetí 29 metrů, takže
ke kolizi s chodcem naštěstí nedojde.
Obr. 40: Detekce kolize mezi automobilem a chodcem
142
27. Rozhodovací příkazy
Přejděme nyní k algoritmizaci fyzikální úlohy:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
int main()
{
int celkovaDraha;
float pocatecniRychlost, reakcniCas, zpomaleni;
float reakcniDraha, brzdnaDraha;
printf(”Zadejte pocatecni rychlost auta (v km/h): ”);
scanf(”%f”, &pocatecniRychlost);
pocatecniRychlost /= 3.6f;
printf(”Zadejte celkovou drahu mezi autem a chodcem (v m): ”);
scanf(”%d”, &celkovaDraha);
printf(”Zadejte delku reakcniho casu (v s): ”);
scanf(”%f”, &reakcniCas);
printf(”Zadejte zpomaleni (v m/s2): ”);
scanf(”%f”, &zpomaleni);
reakcniDraha = pocatecniRychlost * reakcniCas;
brzdnaDraha = -(pocatecniRychlost * pocatecniRychlost) / (2 * zpomaleni);
printf(”Reakcni draha je %.2f m.\n”, reakcniDraha);
printf(”Brzdna dráha je %.2f m.\n”, brzdnaDraha);
printf(”Auto zcela zabrzdi po ujeti %.2f m.\n”, reakcniDraha + brzdnaDraha);
if (reakcniDraha + brzdnaDraha < celkovaDraha)
{
printf(”Mezi autem a chodcem nedojde ke kolizi.”);
}
else
{
printf(”Mezi autem a chodcem dojde ke kolizi.”);
}
return 0;
}
Komentář k zdrojovému kódu jazyka C: Program věrně kopíruje fyzikální výklad,
jejž jsme uvedli, a proto se domníváme, že byste se neměli setkat s žádnými kritickými
pasážemi. Jenom připomínáme, že program očekává zadání záporné hodnoty pro
koeficient zpomalení.
27.6. Rozhodovací příkaz switch
Rozhodovací příkaz switch byl navržen speciálně pro vícecestné rozhodování. Nejprve
uvedeme jeho generický syntaktický skelet a pak si vysvětlíme, jak tento příkaz provádí
své rozhodování.
143
Programování v jaz yce C
28. Programové cykly
Programový cyklus nebo jen cyklus je označení pro iterativní syntaktickou konstrukci, která
umožňuje opakované zpracování množiny příkazů, zpravidla na základě vyhodnocení
stanoveného rozhodovacího výrazu. Programovací jazyk C zná tři základní typy cyklů:
1. Cyklus for
2. Cyklus while
3. Cyklus do-while.
Průchod cyklem se v terminologii programování označuje iterací cyklu. Iterace cyklu tedy
označuje jedno opakování cyklu. Během jedné iterace cyklu jsou postupně zpracovány
všechny programové příkazy, jež jsou umístěny v těle cyklu. Po zpracování každé iterace
přijímá cyklus rozhodnutí o tom, zda bude provedena rovněž další iterace cyklu, či nikoliv.
Toto rozhodnutí obvykle vyplývá z vyhodnocení určitého rozhodovacího výrazu (nebo
podmínky, jak někdy také zkráceně říkáme). V následujících podkapitolách podáme výklad
všech zmíněných cyklů jazyka C.
Obr. 41: Schematický model programového cyklu
28.1. Cyklus for
Schematický model cyklu for má následující podobu:
for(IV; RV; M V)
{
P1; P2; ... Pn;
}
148
28. Programové cykly
První řádek definice cyklu for tvoří hlavičku cyklu. V hlavičce cyklu jsou seskupeny tři
součásti uzavřené v závorkách. Těmito součástmi jsou:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
• IV – inicializační výraz. IV inicializuje řídící proměnnou cyklu for. Každý cyklus,
nejenom cyklus for, pracuje s proměnnou, která řídí jeho život. Z uvedeného důvodu se
tato proměnná označuje termínem řídící proměnná cyklu. I když je na programátorovi,
jaký datový typ, identifikátor a inicializační hodnotu bude řídící proměnná cyklu mít,
v praxi se nejčastěji setkáváme s celočíselnými řídícími proměnnými. V jazyce C musí
být řídící proměnná cyklu for definována před tímto cyklem. Jazyk C neumožňuje, na
rozdíl od jazyků C++, C++/CLI a C#, aby byla řídící proměnná cyklu for definována
přímo v jeho hlavičce. Řídící proměnnou cyklu for tak bude v naprosté většině případů
lokální proměnná, která bude definována v těle funkce, v níž je cyklus for situován. Po
zpracování IV obsahuje řídící proměnná cyklu for požadovanou inicializační hodnotu.
• RV – rozhodovací výraz. Rozhodovací výraz tvoří nutnou součást hlavičky cyklu for,
poněvadž podle hodnoty rozhodovacího výrazu přijímá cyklus rozhodnutí o provedení
své další iterace. Rozhodovacím výrazem smí být jakýkoliv syntakticky korektně
zapsaný a sémanticky smysluplný výraz, jehož hodnotou je buď logická pravda, nebo
logická nepravda. Jestliže je hodnotou RV logická pravda, vykoná se další iterace cyklu
for. Pokud bude naopak hodnotou RV logická nepravda, další iterace cyklu for se
neuskuteční. Za těchto okolností cyklus for končí svou činnost.
• MV – manipulační výraz. Manipulační výraz aplikuje jistou, zpravidla aritmetickou,
manipulační operaci na řídící proměnnou cyklu for. Manipulačním výrazem bývá
inkrementační výraz, jehož smyslem je inkrementovat hodnotu řídící proměnné cyklu
for před vstupem do následující iterace tohoto cyklu. Podobně může manipulačním
výrazem být také dekrementační výraz, který dekrementuje hodnotu řídící proměnné
cyklu for. Ve všeobecnosti ale smíme konstatovat, že manipulačním výrazem cyklu
for může být jakýkoliv validní výraz, který požadovaným způsobem modifikuje stav
řídící proměnné tohoto cyklu.
Tělo cyklu for tvoří konečná a neprázdná množina programových příkazů P1, P2, … Pn,
které jsou ohraničeny složenými závorkami {}. Jestliže bude provedena iterace cyklu for,
dojde ke zpracování všech příkazů uložených v jeho těle.
Podle všeobecného modelu dále zkonstruujeme konkrétní cyklus for a vysvětlíme jeho
pracovní model.
#include <stdio.h>
int main()
{
int i;
for(i = 1; i <= 10; i++)
{
printf(”%d\n”, i);
}
return 0;
}
149
Programování v jaz yce C
Předestřený cyklus for bude zpracován takto:
1. Při vstupu do cyklu se nejprve provede IV. Tento výraz inicializuje řídící proměnnou
cyklu for (s identifikátorem i a datovým typem int). Explicitní inicializační hodnotou
řídící proměnné cyklu je 1.
2. Vyhodnotí se rozhodovací výraz i<=10. Přesněji řečeno, rozhodovací výraz je v tomto
konkrétním případě relačním výrazem. (K tomuto závěru dojdeme snadno, neboť
operátor <= je binárním relačním operátorem.) Rozhodovací výraz vyhodnotíme tak,
že za identifikátor proměnné i dosadíme aktuální hodnotu řídící proměnné cyklu for.
Tou je 1, vyhodnocujeme tedy výraz 1<=10. Relační operátor zjistí, že mezi operandy
1 a 10 existuje relace, protože jednička je menší hodnota než desítka. Hodnotou
rozhodovacího výrazu je logická pravda (1), což cyklus for přiměje k tomu, aby
vykonal svou 1. iteraci. Během ní je vykonán příkaz, jenž se nachází v těle cyklu.
Tento příkaz je dobře srozumitelný: jeho úloha spočívá v zobrazení aktuální hodnoty
řídící proměnné cyklu for (ano, tou bude v 1. iteraci 1).
3. Po vykonání příkazu v těle cyklu for přichází na řadu zpracování manipulačního
výrazu. Tímto výrazem je i++ čili postfixová inkrementace řídící proměnné cyklu.
Všimněme si prosím, že na konci 1. iterace cyklu zvyšujeme hodnotu jeho řídící
proměnné. Z jedničky děláme dvojku a tu vzápětí přiřazujeme do proměnné i. Tím je
1. iterace cyklu for u konce a začíná se další iterace.
4. Ve své 2. iteraci cyklus pomíjí IV a rovnou přechází na testování rozhodovacího
výrazu. Bude dobré, když budeme mít na paměti skutečnost, že IV je zpracováván
pouze jednou, a to při vstupu do cyklu for. Vyhodnocení rozhodovacího výrazu
znamená testování relace mezi operandy 2 a 10 (připomeňme, že aktuální hodnotou
řídící proměnné cyklu je v 2. iteraci dvojka). Přirozeně, tato podmínka je splněna,
a proto cyklus for provede příkaz, který zobrazí aktuální hodnotu řídící proměnné.
Cyklus pokračuje inkrementací řídící proměnné (na hodnotu 3), čímž se končí jeho 2.
iterace.
5. 3. iterace cyklu má podobný průběh jako ta předcházející: cyklus vyhodnocuje
rozhodovací výraz, a protože výsledkem tohoto procesu je opět logická pravda (3<10),
znovu se na výstupu zobrazí aktuální hodnota řídící proměnné cyklu.
6. Charakterizovaná posloupnost operací se opakuje tak dlouho, dokud nebude
hodnotou rozhodovacího výrazu logická nepravda. To se děje v 11. iteraci cyklu,
v níž bude řídící proměnná obsahovat hodnotu 11. Vzhledem k tomu, že výraz 11<=10
není pravdivý, jeho hodnotou bude logická nepravda (0). V této situaci cyklus for
zamítá provedení další iterace a končí svou činnost. Praktickou implikací pracovního
modelu cyklu for je skutečnost, že program obsahující náš cyklus zobrazí na výstupu
posloupnost celých čísel z intervalu <1, 10>.
150
28. Programové cykly
Grafickou podobu pracovního modelu cyklu for uvádíme na obr. 42.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Obr. 42: Pracovní model cyklu for
Cyklus for nám poslouží například při výpočtu faktoriálu libovolného čísla. Jak víme
z matematiky, definice faktoriálu má rekurentně-rekurzivní povahu:
n! = n ×( n-1)! pro každé n ∈ N ∪ {0}, přičemž 0! = 1.
Zdrojový kód programu v jazyce C má následující syntaktický obraz:
#include <stdio.h>
int main()
{
int i, n, faktorial = 1;
printf(”Zadejte n: ”);
scanf(”%d”, &n);
/* Výpočet n! provádí cyklus for. */
for(i = 2; i <= n; i++)
{
faktorial *= i;
}
printf(”%d! je %d.\n”, n, faktorial);
return 0;
}
151
Programování v jaz yce C
Komentář k zdrojovému kódu jazyka C: Zadání pro výpočet faktoriálu patří mezi úlohy,
které elegantně vyřešíme pomocí programového cyklu. V našem případě jsme upotřebili
cyklus for s tímto nastavením:
• V hlavičce cyklu je inicializována řídící proměnná cyklu i typu int. Explicitní inicializační
hodnotou řídící proměnné je 2, což je vzhledem k povaze úlohy pochopitelné.
• Rozhodovací výraz zjišťuje, zda je hodnota řídící proměnné cyklu menší nebo rovna
hodnotě proměnné n (v této proměnné je uložen člen, jehož faktoriál hodláme
vypočítat).
• Manipulačním výrazem je postfixová inkrementace řídící proměnné, což znamená, že na
konci každé iterace cyklu bude hodnota proměnné i zvýšena o 1.
• Do těla cyklu jsme vložili jediný příkaz, který postupně, s probíhajícími iteracemi cyklu,
vypočítavá faktoriál zadaného čísla.
Poznámka: Podotkněme, že příkaz
faktorial *= i;
můžeme ekvivalentně nahradit příkazem
faktorial = faktorial * i;
Pro lepší názornost budeme analyzovat zpracování cyklu for po jednotlivých iteracích pro
výpočet 5! (tab. 12).
Tab. 12: Analýza iterativního výpočtu 5! pomocí cyklu for
Iterace
RV
Je hodnotou RV
logická pravda?
Výraz
Hodnota výrazu (uložena
v proměnné faktorial)
1.
2 <= 5
Ano
1*2
2
2.
3 <= 5
Ano
2*3
6
3.
4 <= 5
Ano
6*4
24
4.
5 <= 5
Ano
24 * 5
120
5.
6 <= 5
Ne
-
120
Jak se dozvíme po spuštění programu, 5! je 120. Zkusme s programem trošičku
experimentovat a zjišťujme faktoriály dalších přirozených čísel. Jenom berme v potaz,
že hodnoty faktoriálů rostou docela rychle. Kupříkladu 10! představuje číslo větší než
3,6 milionu.
152
29. Funkce
29. Funkce
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
V ryze strukturovaném programovacím jazyce, jakým je jazyk C, je funkce základní
stavební buňkou každého správně navrženého strukturovaného programu. Mnozí autoři
funkci velice často definují jako podprogram, který provádí exaktní algoritmizaci řešené
úlohy. Techničtěji bychom mohli funkci popsat jako vyhrazený blok programového kódu,
který obsahuje konečnou a neprázdnou množinu programových příkazů. Tyto příkazy
implementují určitý algoritmus a jejich zpracování vede k vykonání algoritmu a k nalezení
řešení úlohy.
Každý strukturovaný program obsahuje hlavní funkci main, která vystupuje jako vstupní
bod tohoto programu. Když uživatel vydá pokyn na spuštění programu, operační systém
automaticky zavolá hlavní funkci main a zahájí zpracování jejích příkazů.
Poznámka: Podobně na funkce nahlížejí i programovací jazyky, k nimž řadíme C++, C# nebo
C++/CLI – ty ovšem navíc funkce zapouzdřují do tříd coby abstraktních objektových uživatelsky
deklarovaných datových typů. O těchto jazycích říkáme, že jsou hybridní, což je dáno tím, že
kromě strukturovaného paradigmatu zavádějí rovněž objektově orientované paradigma vývoje
počítačového softwaru. Ve všeobecnosti platí, že když je programovací jazyk hybridní, tak v sobě
integruje syntakticko-sémantické konstrukce pro podporu více programovacích paradigmat.
Všechny programy jazyka C, které jsme dosud společně vytvořili, obsahují hlavní funkci
main. V této kapitole se naučíme, jak mohou programátoři vytvářet své vlastní, takzvané
uživatelsky definované funkce. Poté si ukážeme, jak se uskutečňuje komunikační dialog
mezi hlavní funkcí main a uživatelsky definovanými funkcemi.
Když budeme chtít v jazyce C vytvořit svou vlastní funkci, budeme ji muset deklarovat
a definovat. V terminologii programování jsou termíny „deklarace funkce“ a „definice
funkce“ velice významné. Není správné tyto termíny zaměňovat, neboť každý determinuje
odlišnou programovou konstrukci.
Deklarace funkce je příkaz, který překladači oznamuje, že chceme vytvořit svou
vlastní funkci. Když funkci deklarujeme, zavedeme do zdrojového kódu jazyka C její
prototyp. Dovolíme si poznamenat, že v praxi se termíny „deklarace funkce“ a „prototyp
funkce“, respektive „deklarace funkce“ a „funkční prototyp“ volně zaměňují. To je
v pořádku, protože oba termíny mají synonymický význam, přičemž identifikují totožnou
programovou konstrukci.
Prototyp funkce sděluje překladači následující informace o funkci:
• Datový typ návratové hodnoty funkce
• Identifikátor funkce
• Seznam formálních parametrů funkce
157
30. Struktury
30. Struktury
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Struktura je v programovacím jazyce C agregovaný heterogenní uživatelsky deklarovaný
datový typ (UDDT). Struktura se skládá z konečné a neprázdné množiny datových členů, jež
jsou ze syntaktické stránky nejčastěji reprezentovány proměnnými primitivních datových
typů. Každý datový člen správně deklarované struktury musí mít svůj identifikátor
a datový typ.
Struktury umožňují efektivně modelovat datové entity reálného světa. Díky tomu, že
struktury provádějí zapouzdření datových členů do jednoho logického celku, dovolují
nám pracovat s množinou spřízněných datových členů jako s jedním datovým objektem.
Pomocí struktur dovedeme modelovat například následující entity:
1. Student – charakterizovaný svým jménem, příjmením, adresou, ročníkem studia,
počtem zapsaných předmětů, počtem dosažených kreditů atd.
2. Vysokoškolský pedagog – charakterizovaný svým jménem, příjmením, adresou,
mzdou, funkčním zařazením, počtem vyučovaných předmětů, počtem odborných
publikací a vědeckých prací atd.
3. Počítač – charakterizovaný procesorem, počtem výpočetních jader uvnitř procesoru,
kapacitou operační paměti, úložním prostorem pevného disku, modelem zvukové
a grafické karty, cenou atd.
4. MP3 přehrávač – charakterizovaný kapacitou operační paměti, počtem skladeb, počtem
podporovaných multimediálních formátů, barvou svého krytu, cenou, možností
přehrávat videosoubory atd.
5. Automobil – charakterizovaný výkonem motoru (v KW), spotřebou (v litrech na 100 km),
cenou, počtem míst na sezení, počtem dveří, barvou karoserie, délkou, šířkou a výškou atd.
6. Výrobek – charakterizovaný svým identifikačním číslem, názvem, cenou, složením
komponent atd.
7. Matematický vektor – charakterizovaný uspořádanou n-ticí celočíselných nebo
reálných hodnot.
8. Programové vlákno fyzického procesu programu jazyka C – charakterizované svým
identifikátorem, alokační kapacitou přiděleného paměťového prostoru, prioritou,
stavem, celkovým časem provádění atd.
Jak si můžeme všimnout, pomocí struktur můžeme modelovat nejenom živé entity
(student, vysokoškolský učitel), ale i neživé entity (počítač, automobil). Neživé entity lze
rozdělit na hmotné neživé entity a nehmotné (abstraktní) neživé entity. Abstraktní entitou
je třeba vektor, ale také integrál, rovnice nebo jakýkoliv jiný matematický objekt. Struktury
samozřejmě umí popsat datové složení všech zmíněných typů entit.
169
30. Struktury
30.4. Použití inicializované instance struktury
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Po instanciaci a inicializaci instance může být tato nabídnuta klientům k přímé manipulaci.
Klienti mohou číst hodnoty datových členů instance nebo je měnit podle svých potřeb.
Následující ukázka mění složky 3D vektoru a vzápětí je zobrazuje na výstupu:
#include <stdio.h>
struct Vektor3D
{
int x, y, z;
};
int main()
{
struct Vektor3D vektor;
vektor.x = vektor.y = vektor.z = 1;
printf(”Slozky 3D vektoru po inicializaci: %d, %d, %d.\n”,
vektor.x, vektor.y, vektor.z);
vektor.x += 1;
vektor.y += 2;
vektor.z += 3;
printf(”Slozky 3D vektoru po reinicializaci: %d, %d, %d.\n”,
vektor.x, vektor.y, vektor.z);
return 0;
}
Komentář k zdrojovému kódu jazyka C: Ihned poté, co vytvoříme a inicializujeme nový
3D vektor, zobrazujeme jeho složky na výstupu. V další etapě pak provádíme reinicializaci
3D vektoru, přičemž upravenou podobu jeho složek rovněž zobrazujeme na výstupu.
Samozřejmě můžeme stávající zdrojový kód upravit tak, abychom dovedli s 3D vektorem
uskutečnit jistou manipulační operaci, kupříkladu jej vynásobit skalárem:
#include <stdio.h>
struct Vektor3D
{
int x, y, z;
};
int main()
{
struct Vektor3D vektor;
int skalar;
printf(”Zadejte slozky 3D vektoru (jako cela cisla oddelena mezerami): ”);
scanf(”%d %d %d”, &vektor.x, &vektor.y, &vektor.z);
printf(”Zadejte skalar (jako cele cislo), jenz bude pouzit k modifikaci 3D vektoru: ”);
scanf(”%d”, &skalar);
printf(”Puvodni 3D vektor: %d, %d, %d.\n”, vektor.x, vektor.y, vektor.z);
vektor.x *= skalar;
vektor.y *= skalar;
vektor.z *= skalar;
printf(”Novy 3D vektor: %d, %d, %d.\n”, vektor.x, vektor.y, vektor.z);
return 0;
}
175
Programování v jaz yce C
Komentář k zdrojovému kódu jazyka C: Pomineme-li standardní pracovní postup se
strukturou Vektor3D, tak jedinou obměnou je uživatelská inicializace vytvořeného 3D
vektoru (uživatel sám zadá na vstupu hodnoty, jež budou posléze uloženy do příslušných
datových členů instance struktury Vektor3D).
Poznámka: Když voláme funkci scanf za účelem načtení více hodnot najednou, zadáváme více
formátových specifikátorů (v našem případě jsou 3). V řídícím řetězci funkce scanf jsou tyto
formátové specifikátory odděleny mezerami. To znamená, že uživatel zadá na vstupu 3 celočíselné
hodnoty (složky 3D vektoru), které budou také odděleny mezerami (ekvivalentně mohou být tyto
hodnoty odděleny rovněž symboly nového řádku, které vložíme stiskem klávesy ENTER).
Program na výstupu zobrazí nejprve složky 3D vektoru neprodleně po jeho uživatelské
inicializaci a poté nás obeznámí rovněž s podobou nového 3D vektoru, který vzešel
z multiplikativní operace se skalárem.
Kromě vynásobení 3D vektoru skalárem smíme uskutečnit také součet a rozdíl dvou 3D
vektorů. Více informací již podává další program jazyka C:
#include <stdio.h>
struct Vektor3D
{
int x, y, z;
};
int main()
{
/* Vytvoření 4 3D vektorů. */
struct Vektor3D vektor1, vektor2;
struct Vektor3D souctovyVektor, rozdilovyVektor;
/* Inicializace vytvořených 3D vektorů. */
printf(”Zadejte slozky 1. 3D vektoru (jako cela cisla oddelena mezerami): ”);
scanf(”%d %d %d”, &vektor1.x, &vektor1.y, &vektor1.z);
printf(”Zadejte slozky 2. 3D vektoru (jako cela cisla oddelena mezerami): ”);
scanf(”%d %d %d”, &vektor2.x, &vektor2.y, &vektor2.z);
/* Vypočtení součtového 3D vektoru. */
souctovyVektor.x = vektor1.x + vektor2.x;
souctovyVektor.y = vektor1.y + vektor2.y;
souctovyVektor.z = vektor1.z + vektor2.z;
/* Vypočtení rozdílového 3D vektoru. */
rozdilovyVektor.x = vektor1.x - vektor2.x;
rozdilovyVektor.y = vektor1.y - vektor2.y;
rozdilovyVektor.z = vektor1.z - vektor2.z;
/* Zobrazení složek všech 3D vektorů na výstupu. */
printf(”1. 3D vektor: %d, %d, %d.\n”, vektor1.x, vektor1.y, vektor1.z);
printf(”2. 3D vektor: %d, %d, %d.\n”, vektor2.x, vektor2.y, vektor2.z);
printf(”Souctovy vektor: %d, %d, %d.\n”, souctovyVektor.x, souctovyVektor.y,
souctovyVektor.z);
printf(”Rozdilovy vektor: %d, %d, %d.\n”, rozdilovyVektor.x, rozdilovyVektor.y,
rozdilovyVektor.z);
return 0;
}
176
Programování v jaz yce C
Závěr
Když zvládnete algoritmizaci a programování v jazyce C, přičemž najdete v programování
zalíbení, je rozumné zvážit potenciální cesty budoucího rozvoje vašeho odborného profilu.
Abyste měli představu, co vám může tento svět nabídnout, uvádíme možné směry dalšího
postupu:
1. Seznamte se s datovými strukturami a algoritmy, které s nimi manipulují.
2. Absolvujte pokročilý kurz programátorských technik v jazyce C.
3. Naučte se jazyk C++ a ovládněte základy objektově orientovaného programování
(OOP).
4. Studujte jazyk C# a naučte se vytvářet programy s grafickým uživatelským rozhraním
s podporou OOP.
5. Věnujte čas paralelnímu a paralelnímu objektově orientovanému programování
(POOP) v jazycích C, C++ a C#.
Zvládnete-li tuto pětihvězdičkovou sadu programátorských kurzů, pak z vás budou
opravdové IT hvězdy. Vaše hodnota na trhu práce bude enormně vysoká a možnosti takřka
nekonečné. A můžete udělat vše pro to, aby se z tohoto světa stalo lepší místo pro život!
O autorovi
Ing. Ján Hanák, Ph.D., MVP, vystudoval Ekonomickou univerzitu v Bratislavě. Pracuje jako
vysokoškolský pedagog na zdejší Katedře aplikované informatiky Fakulty hospodářské
informatiky (KAI FHI). Přednáší a vede semináře týkající se programování a vývoje
počítačového softwaru v programovacích jazycích C, C++ a C#. Kromě zmíněné trojice
jazyků patří k jeho oblíbeným programovacím prostředkům také Visual Basic, C++/CLI
a F#. Je nadšeným autorem odborné počítačové literatury. V jeho portfoliu můžete najít
následující knižní tituly:
1. Programování v jazyce C. Kralice na Hané: Computer Media, 2010.
2. C++: Akademický výučbový kurz. Bratislava: Vydavateľstvo EKONÓM, 2010.
3. Inovácie v jazykoch Visual Basic 2010, C# 4.0 a C++. Brno: Artax, 2010.
4. Visual Basic 2010 – Hotové riešenia. Bratislava: Microsoft Slovakia, 2010.
5. C#: Akademický výučbový kurz, 2. aktualizované a rozšírené vydanie. Bratislava:
Vydavateľstvo EKONÓM, 2010.
6. Praktické paralelné programovanie v jazykoch C# 4.0 a C++. Brno: Artax, 2009.
7. C++/CLI – Praktické príklady. Brno: Artax, 2009.
214
Nadpis kapitoly
8. C# 3.0 – Programování na platformě .NET 3.5. Brno: Zoner Press, 2009.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
9. C++/CLI – Začínáme programovat. Brno: Artax, 2009.
10. C#: Akademický výučbový kurz. Bratislava: Vydavateľstvo EKONÓM, 2009.
11. Základy paralelného programovania v jazyku C# 3.0. Brno: Artax, 2009.
12. Objektovo orientované programovanie v jazyku C# 3.0. Brno: Artax, 2008.
13. Inovácie v jazyku Visual Basic 2008. Praha: Microsoft, 2008.
14. Visual Basic 2008: Grafické transformácie a ich optimalizácie. Bratislava: Microsoft
Slovakia, 2008.
15. Programovanie B – Zbierka prednášok (Učebná pomôcka na programovanie v jazyku
C++). Bratislava: Vydavateľstvo EKONÓM, 2008.
16. Programovanie A – Zbierka prednášok (Učebná pomôcka na programovanie
v jazyku C). Bratislava: Vydavateľstvo EKONÓM, 2008.
17. Expanzívne šablóny: Príručka pre tvorbu "code snippets" pre Visual Studio.
Bratislava: Microsoft Slovakia, 2008.
18. Kryptografia: Príručka pre praktické odskúšanie symetrického šifrovania v .NET
Framework-u. Bratislava: Microsoft Slovakia, 2007.
19. Príručka pre praktické odskúšanie vývoja nad Windows Mobile 6.0. Bratislava:
Microsoft Slovakia, 2007.
20. Príručka pre praktické odskúšanie vývoja nad DirectX. Bratislava: Microsoft Slovakia,
2007.
21. Príručka pre praktické odskúšanie automatizácie aplikácií Microsoft Office 2007.
Bratislava: Microsoft Slovakia, 2007.
22. Visual Basic 2005 pro pokročilé. Brno: Zoner Press, 2006.
23. C# – praktické příklady. Praha: Grada Publishing, 2006.
24. Programujeme v jazycích C++ s Managed Extensions a C++/CLI. Praha: Microsoft,
2006.
25. Přecházíme z jazyka Visual Basic 6.0 na jazyk Visual Basic 2005. Praha: Microsoft,
2005.
26. Visual Basic .NET 2003 – Začínáme programovat. Praha: Grada Publishing, 2004.
V letech 2006 – 2010 byl jeho přínos vývojářským komunitám oceněn celosvětovými
vývojářskými tituly Microsoft Most Valuable Professional (MVP) s kompetencí Visual
Developer – Visual C++.
215
Programování v jaz yce C
Společnost Microsoft ČR udělila Ing. Jánovi Hanákovi, MVP, v roce 2009 ocenění za
mimořádně úspěšné odborné knižní publikace „Objektovo orientované programovanie
v jazyku C# 3.0“ a „Inovácie v jazyku Visual Basic 2008“.
Společnost Microsoft Slovakia udělila Ing. Jánovi Hanákovi, MVP, v roce 2009 ocenění
za zlepšování akademického ekosystému a za signifikantní rozšiřování technologií
a programovacích jazyků Microsoftu na akademické půdě.
Kontakt s vývojáři a programátory udržuje zejména prostřednictvím technických
seminářů a odborných konferencí, na nichž aktivně vystupuje. Za všechny vybíráme tyto:
• Technický seminář Vývojářské technologie a nástroje pro vývoj softwarových
produktů nové generace. KAI FHI EU a Microsoft Slovakia. Bratislava 29. 4. 2010.
• Technický seminář Paralelné programovanie. KAI FHI EU a Microsoft Slovakia.
Bratislava 21. 10. 2009.
• Konference Software Developer 2007, příspěvek na téma Představení produktu
Visual C# 2005 a jazyka C# 3.0. Praha 19. 6. 2007.
• Technický seminář Novinky ve Visual C# 2005. Microsoft Slovakia. Bratislava 3. 10. 2006.
• Technický seminář Visual Basic 2005 a jeho cesta k Windows Vista. Microsoft Slovakia.
Bratislava 27. 4. 2006.
Jako autor má letité zkušenosti s působením v elektronických a tištěných médiích. Během
své kariéry pracoval na pozici odborného autora nebo odborného redaktora v následujících
počítačových časopisech:
PC WORLD, SOFTWARE DEVELOPER, CONNECT!, COMPUTERWORLD, INFOWARE,
PC REVUE a CHIP.
Dohromady publikoval více než 250 odborných a populárních prací věnovaných vývoji
počítačového softwaru.
Autora můžete zastihnout na následující adrese elektronické pošty: [email protected].
216