Jazyk C. středa 8:50 A3 úterý 14:20 HI3

Jazyk C

středa 8:50 A3 úterý 14:20 HI3

Úvodní strana Titulní strana Obsah

Petr Kolář místnost A-10 tel: +420-485 353 673 e-mail:

[email protected]

WWW: http://www.kai.vslib.cz/~kolar/cecko/ Pracovní verze!

JJ

II

J

I

Strana 1 z 89 Zpět Celá obrazovka Zavřít Konec

Literatura • Herout, P.: Učebnice jazyka C, III upravené vydání. Kopp, České Budějovice 1994. ISBN 80-85828-21-9. – doporučeno • Kernighan, B. W. – Ritchie, D. M.: The C Programming Language. Second Edition. Prentice Hall 1988. ISBN 0-13-110362-8, K&R – klasická učebnice, která ovšem popisuje dnes již zastaralou „normuÿ jazyka

Úvodní strana

• Kernighan, B. W. – Ritchie, D. M.: Programovací jazyk C. SNTL – Alfa, Bratislava 1988 – slovenský překlad prvního vydání předchozího titulu

Obsah

Titulní strana

JJ

II

J

I


Překladače jazyka C Kompletní profesionální vývojové prostředí pro jazyk C mívá cenu desítek tisíc Kč. Úvodní strana

Existuje však řada volně dostupných překladačů a jednoduchých vývojových prostředí, které jsou pro výuku plně dostačující: V OS Linux je vývojové prostředí s gcc, gdb, součástí prakticky všech distribucí. Pro Windows: DJGPP http://www.delorie.com/djgpp/ – kompletní aktuální vývojové prostředí (ovšem s uživatelským rozhraním poplatným MS-DOSu a roku 1990). Archivy zabírají asi 20 MB (nebo více podle množství použitých balíků). Výběr souborů se provádí pomocí ZIP Picker. V Čechách zrcadleno na serveru ftp://ftp.zcu.cz/pub/win/simtelnet/gnu/djgpp/. Borland Museum: http://community.borland.com/museum/ – starší verze integrovaného prostředí s překladačem C od firmy Borland. Turbo C++ verze 1.01 (2,7 MB) nebo Turbo C verze 2.01 (1,1 MB).

Titulní strana Obsah

JJ

II

J

I


Srovnání jazyků Pascal a C C pro praktické programování původním „standardemÿ je kniha K&R, standardy z let 1989-90 a 1999 „language of choiceÿ modulární programování (oddělená kompilace) objektová rozšíření C++, Objective C, C# rozsáhlé standardní knihovny jsou volnou součástí jazyka, množství dalších knihoven

Pascal pro výuku od počátku existence standardu jazyka, je však příliš omezující → rozšíření „language of bondage and disciplineÿ modulární programování v rozšířeních objektové rozšíření Turbo Pascal, Delphi standardní funkce jsou nedílnou součástí jazyka


JJ

II

J

I

Strana 4 z 89 Zpět Celá obrazovka Zavřít

#include <stdio.h>

Konec

int main() { printf("Hello, world!\n"); return 0; }

program Hello(Output); begin Writeln(’Hello, world!’); end.

Proč jazyk C? C je univerzální programovací jazyk. Proč jazyk C stojí za pozornost mezi desítkami jiných univerzálních programovacích jazyků? Jedná se o jazyk pro opravdové programování. Niklaus Wirth, autor jazyka Pascal, věnoval značné úsilí, aby jeho jazyk, určený pro výuku programování, byl co možná nejbezpečnější, aby bylo obtížné v něm programovat ošklivě. Popularita jaké Pascal dosáhl, svědčí o tom, že Wirth vytvořil něco lepšího, než o co usiloval. Nicméně něco je možné napsat ve standardním Pascalu jen s velkým úsilím, něco vůbec ne. Obhájci Pascalu se chlubí, že Pascal má od začátku závaznou normu, ale neprogramují v ní. Množství vzájemně nekompatibilních rozšíření (nejvýznamnější z nich je asi Turbo Pascal) svědčí o tom, že standardnímu Pascalu mnoho užitečných rysů chybí.


JJ

II

J

I

Strana 5 z 89 Zpět

Jazyk C prošel několikaletým vývojem, kdy se skutečně používal i na věci nesnadné a komplikované (přenos operačního systému Unix na počítače několika značně odlišných typů). Během vývoje byl doplněn o vlastnosti, které se ukázaly jako užitečné (např. prototypy funkcí), a naopak některé vlastnosti matoucí, zbytečně složité nebo zbytečné byly odstraněny. Důležitými mezníky vývoje jazyka C bylo vydání jeho standardů – ANSI X3.159-1989, ANSI/ISO/IEC 9899:1990 a ISO/IEC 9899:1999. Jazyk C vytvořili programátoři pro programátory. Díky tomu neobsahuje podobné přehmaty jako parametry procedur volané jménem z jazyka Algol 60

Celá obrazovka Zavřít Konec

– vlastnost, která se obtížně implementuje, nepříliš efektivně překládá a přitom je možné ji nahradit něčím mnohem čistším a průhlednějším (parametry volanými referencí), nebo „návaznostÿ souborů na operační systém pomocí parametrů programu v Pascalu. Způsob zápisu algoritmů v jazyce C je velice podobný zápisu v jazycích Algol, Pascal, Basic, PL/I, Modula–2, Ada, což tyto jazyky favorizuje před jazyky s méně obvyklou syntaxí (Fortran, Cobol, Forth, Perl, . . . ). Syntaxe jazyka C umožňuje stručné vyjádření algoritmu a navíc často naznačuje překladači možnost optimalizace. Jazyk C umožňuje oddělený překlad jednotlivých částí programu, používání a vytváření knihoven. Díky tomu je možné jej používat i na rozsáhlé projekty a pro týmovou práci. Jazyk C nepokutuje programátora za použití některých svých vlastností (číselná návěští v Pascalu s nutností je předem deklarovat, logické spojky and a or v Pascalu s povinným vyhodnocením obou operandů), ani nenabízí „mocnéÿ konstrukce, které je snadné použít, ale které vedou ke komplexním operacím a k udivení nad pomalým během programu. Většinu příkazů jazyka je možné přeložit jednou nebo několika málo strojovými instrukcemi. Jazyk C je relativně jednoduchý. Nejedná se o ohromné monstrum, jakým je například jazyk PL/I (O) nebo dokonce Ada, pro kterou několik let neexistoval překladač. Nejedná se ani o jazyk, na který si činí vlastnické právo některá firma či jiná organizace. Jazyk C je k dispozici na většině platforem, od jed-


JJ

II

J

I


nočipových mikropočítačů (překladače pro ně samozřejmě pracují na větších strojích – jedná se o tzv. křížové překladače; cross compilers), přes domácí a osobní počítače, pracovní stanice, střediskové počítače až k superpočítačům. Nejrozšířenější operační systémy (DOS a UNIX) jsou napsány jazyce C. Jazyk C nenutí programátora použít jediný správný přístup; tentýž algoritmus je možné zapsat s použitím různých prostředků a do různé míry zhuštěně. C je typickým jazykem volby. Programování v jazyce C však přináší i některá nebezpečí. Některé konstrukce mohou různé překladače chápat odlišně – speciálně se to týká datových typů – rozsah stejně pojmenovaných celočíselných typů je v různých prostředích různý. Také reprezentace složených typů může být v programech vytvořených různými překladači různá, což může způsobovat chyby při výměně souborů nebo síťové komunikaci. Téměř žádný překladač nehlídá přetečení rozsahu číselných hodnot. U funkcí s proměnným počtem parametrů se typy těchto parametrů nekontrolují. Při práci s řetězci a ukazateli se lze snadno dopustit chyb, které překladač neodhalí. Standardní knihovna obsahuje funkce, jejichž používání je nebezpečné (gets). Některé konstrukce může překladač chápat díky opomenutí programátora jinak, než byly zamýšleny. Mezi časté chyby patří například použití operátoru = namísto == pro porovnávání, zapomenutí příkazu break na konci větve uvnitř switch, neuvedení hlavičkového souboru pro použité funkce, chybné používání ukazatelů a nesprávné sestavení programu.


JJ

II

J

I


Lexikální symboly Stejně jako jsou základním stavebním kamenem přirozeného jazyka slova, ze kterých se skládají věty, základním stavebním kamenem programu v jazyce C jsou lexikální symboly, ze kterých se skládají příkazy, definice a deklarace: čeština slovo věta, odstavec text

jazyk C lexikální symbol příkaz, deklarace, definice kompilační jednotka

Jazyk C rozlišuje šest tříd lexikálních symbolů:


JJ

II

J

I

Strana 8 z 89

• Identifikátory • Klíčová slova • Konstanty

Zpět Celá obrazovka

• Řetězce

Zavřít

• Operátory

Konec

• Ostatní oddělovače

Identifikátory Identifikátory – začínají písmenem nebo znakem podtržítko (_) a obsahují alfanumerické znaky, tj. písmena, číslice a znaky podtržítko; nepoužívejte identifikátory začínající podtržítkem, pokud nevíte, co děláte.

Úvodní strana Titulní strana

Klíčová slova Klíčová slova – několik desítek vybraných slov, které mají speciální význam v programu v jazyce C.

Obsah

JJ

II

J

I

Strana 9 z 89

Konstanty Zpět

V jazyce C lze používat celočíselné, reálné a znakové konstanty. Řetězcové konstanty jsou považovány za zvláštní druh lexikálních symbolů.

Celá obrazovka Zavřít

Celočíselné mohou být zapsány v desítkové, osmičkové nebo šestnáctkové soustavě; reálné pouze v desítkové soustavě.

Konec

Celočíselné konstanty Celočíselné konstanty začínají vždy číslicí. • konstanta, která začíná 0x nebo 0X, je zapsána v šestnáctkové soustavě, skládá se z číslic a písmen a až f nebo A až F, které reprezentují číslice 10 až 15

Úvodní strana

• pokud konstanta začíná 0, je zapsána v osmičkové soustavě, a může obsahovat pouze číslice 0 až 7

Obsah

• pokud konstanta začíná jinou číslicí než 0, je v desítkové soustavě Pokud konstanta přesahuje největší číslo typu int, je typu long; jinak je typu int. Celočíselné konstanty mohou být (bez ohledu na to, v jaké jsou zapsány číselné soustavě) zakončeny znaky U, L, UL, LL, nebo ULL, které stanovují, že se číslo má považovat za konstantu typu unsigned, long, unsigned long, long long, resp. unsigned long long. Toto zakončení lze psát i malými písmeny, ovšem malé l se snadno plete s číslici 1.

Titulní strana

JJ

II

J

I


Reálné konstanty Reálné konstanty vyhovují následujícímu syntaktickému diagramu: To znamená, že reálné konstanty začínají číslicí nebo desetinnou tečkou a musí být zapsány v desítkové soustavě; skládají se z mantisy a nepovinného exponentu; mantisa obsahuje aspoň jednu číslici a nejvýše jednu desetinnou tečku, exponent je uveden znakem e nebo E, za kterým může být znaménko + nebo - a alespoň jedna číslice; reálná konstanta může být zakončena znakem f nebo F, která zajistí, že konstanta bude typu float a nikoli typu double. Příklady reálných konstant: 1.0, 0., .5, -12.345e27.


JJ

II

J

I


Znakové konstanty Libovolný tisknutelný znak (včetně mezery) s výjimkou znaku apostrof mezi znaky apostrof: ’ ’, ’\"’, ’A’, ’6’. Nebo escape posloupnost mezi znaky apostrof: \n \11 \n \r \t \b \f \\ \’ \"

kód řídícího znaku v osm.soust bez 0 znak s kódem 9 (v kódu ASCII znak TAB) znak konce řádku (newline) návrat vozíku (carriage return) tabelátor (tab) backspace (o znak zpět) form feed (přechod na novou stránku) znak \ znak ’ znak "


JJ

II

J

I

Strana 12 z 89 Zpět Celá obrazovka

Znakové konstanty jsou typu char. Zavřít Konec

Řetězce Řetězec je posloupnost (může být i prázdná) tisknutelných znaků různých od znaku uvozovky (") a escape posloupností jako u konstant typu char uzavřená mezi znaky uvozovky:

Úvodní strana

"Ahoj", "\"", "\r\n"

Titulní strana

Dlouhé řetězce lze na libovolném místě rozdělit znakem uvozovky, odřádkováním, libovolným počtem mezer a dalšími uvozovkami. Řetězce se chovají jako pole znaků s paměťovou třídou static. Překladač vyhradí v paměti tolik bytů, kolik znaků nebo escape posloupností obsahuje řetězec, plus jeden navíc a do každého bytu uloží jeden znak (nebo hodnotu zadanou escape posloupností) a na konec přidá znak ’\0’. Většina řetězcových funkcí pracuje s těmito řetězci zakončenými znakem s kódem 0, řetězec sám proto znak s kódem 0 nesmí obsahovat, funkce by jej považovaly za konec řetězce.

Obsah

JJ

II

J

I


Operátory Operátory jsou tvořeny jedním nebo více nealfanumerickými znaky. Kromě notoricky známých operátorů +, -, *, /, <, >, <=, >= a ( ) obsahuje jazyk další více či méně exotické operátory:

Konec

Prior. 1 1 1 2 2 2 2 2

Operátor ( ) [ ] -> . ! ~ + ++ -& *

Vyhodn. −→

Oper. −

−→ −→ ←− ←− ←−

2 2 1 1 1

←− ←−

1 1

* / %

←− ←− −→

1 1 2

+ << >> < <= > >= == != & ^ | && ||

−→ −→ −→ −→ −→ −→ −→ −→ −→

2 2 2 2 2 2 2 2 2

2 3 4

(type)

5 6 7 8 9 10 11 12 13

sizeof

Význam pořadí vyhodnocování, parametry funkce přístup k prvku pole přístup k položce záznamu logická negace, bitová negace unární plus, unární minus inkrement (+1), dekrement (−1) ukazatel na objekt objekt, na který ukazatel ukazuje změna typu velikost objektu v bytech násobení, dělení, zbytek po dělení sčítání, odčítání bitový posun vlevo, vpravo porovnání je rovno, není rovno bitové and bitové xor bitové or logické and logické or


JJ

II

J

I


14 15 15

? : = *= /= %= += -=

←− ←− ←−

3 2 2

15 15 16

&= ^= |= <<= >>= ,

←− ←− −→

2 2 2

podmíněný výraz přiřazení, znásobení, vydělení zbytek po dělení, přičtení, odečtení bitové and, xor, or posunutí doleva, doprava vyhodnotit zleva doprava, použít poslední výsledek


Slouží pro jednotlivé operace (například + pro sčítání, - pro odčítání, = pro přiřazení hodnoty, == pro test na rovnost, -> pro přístup k položce záznamu, na který ukazuje ukazatel, [ ] pro přístup k prvku pole a podobně)

JJ

II

J

I

Strana 15 z 89

Ostatní oddělovače Ostatní oddělovače – symboly používané zejména pro oddělování příkazů jako {, }, ;, apod.

Zpět Celá obrazovka Zavřít Konec

Bílé znaky Překladač při zpracování programu rozděluje vstupní text na lexikální symboly tak, že vždy načítá co nejdelší posloupnost znaků, která může být lexikálním symbolem. Příkaz a4=210*297; je možné psát bez mezer, protože

se v něm střídají identifikátory a konstanty složené z alfanumerických znaků s operátory a oddělovači z nealfanumerických znaků. Jméno typu int a identifikátor main však musí být odděleny alespoň jedním znakem mezera, tabelátor nebo znak konce řádku (tzv. bílé znaky), protože jinak by je překladač považoval za identifikátor intmain. Mezi libovolné dva lexikální symboly je možné napsat jakýkoli počet bílých znaků pro zpřehlednění programu.


Direktivy preprocesoru Zvláštní pravidla platí pro direktivy preprocesoru, které začínají znakem křížek (#) a jménem direktivy, a musí být na samostatném řádku. Jedná se zejména o příkazy pro vkládání souborů #include <soubor.h> #include "soubor.h"

pro definice konstant a maker #define JMENO hodnota #define makro(p1) ((p1)*(p1))

a pro podmíněný překlad #ifdef JMENO #if výraz #else #endif.

JJ

II

J

I


Komentáře Součástí bílých míst oddělujících lexikální symboly mohou být i komentáře. Tradiční komentáře v jazyce C začínají dvojicí znaků /*, končí dvojicí */ a není je možné vnořovat. Většina novějších překladačů umí pracovat i s komentáři používanými v jazyce C++, které začínají dvojicí znaků // a končí s koncem řádku.


Protože není možné komentáře vnořovat, je problém s vykomentováváním částí programu – pokud bychom použili standardní komentář mezi /* a */ a vykomentovaná část programu by obsahovala také komentáře, překladač by první dvojici znaků */ pochopil jako konec komentáře a další text by se pokoušel překládat. V takovém případě je možné pro vykomentovávání částí programu používat direktivu preprocesoru pro podmíněný překlad – například takto:

JJ

II

J

I


#ifdef 0 ... vykomentovaná část programu /* může obsahovat komentáře, ale nesmí obsahovat * křížící se direktivy preprocesoru #if, #else, #endif */ #endif

Zavřít Konec

Výraz, kterým se přiřazuje do proměnné a4 součin čísel 210 a 297 je možné psát a4 = 210 * 297 ;

ale i a4=210*297; Úvodní strana

nebo a4

=

Titulní strana

210

Obsah

* 297

;

JJ

II

J

I


První program Snad každá kniha o jazyce C začíná ukázkou jednoduchého programu v tomto jazyce – programu, který vypíše na obrazovku nápis Hello, world! a odřádkuje. Zde je tento program:


#include <stdio.h> Obsah

main() { printf("Hello, world!\n"); }

JJ

II

J

I

Strana 19 z 89

Jazyk C prošel od svého vzniku určitým vývojem, takže novější překladače budou pravděpodobně vypisovat při překladu uvedeného programu varování. Text programu upravený podle současných standardů vypadá takto:

Zpět Celá obrazovka Zavřít

#include <stdio.h> int main() { printf("Hello, world!\n"); return 0; }

Konec

Jazyk C používá volný formát zápisu, který programátorovi umožňuje různými způsoby formátovat zdrojový text. Program by bylo možné zapsat kompaktněji takto: #include <stdio.h> int main(){printf("Hello, world!\n");return 0;}

Text #include <stdio.h>, stejně jako další příkazy začínající znakem # musí být na samostatném řádku; jedná se o direktivy preprocesoru, pro které platí zvláštní pravidla. Ze zbývajícího textu bylo možné odstranit většinu mezer a odřádkování (kromě mezery mezi slovy int a main, která by bez mezery splynula v jedno slovo intmain). Výsledný zápis je ale méně přehledný než předešlý, takže je lépe se takovémuto „šetřeníÿ vyhýbat.


JJ

II

J

I

Strana 20 z 89 Zpět

Na programu je vidět několik podstatných rysů: Celá obrazovka

• Procedura printf není součástí jazyka, ale patří do standardní knihovny. Aby ji bylo možné použít, musí být do programu pomocí direktivy preprocesoru #include vložen hlavičkový soubor obsahující mj. deklaraci funkce printf. • Hlavní program je funkce se jménem main. • Za jménem funkce se vždy píší závorky (i když jsou prázdné).

Zavřít Konec

• Pro tisk na standardní výstup (normálně na obrazovku, ale je možné přesměrovat), se používá procedura printf. • Odřádkování se zajistí vložením posloupnosti \n do tisknutého řetězce. • Pro ohraničení bloku slouží složené závorky { a }, a nikoli příkazy begin a end.


JJ

II

J

I


Jednoduché typy Ve standardu jazyka C jsou následující typy: char, unsigned char, signed char, short, unsigned short, int, unsigned, long, unsigned long, float a double.


Celočíselné typy typ signed char unsigned char short unsigned short int unsigned long unsigned long long long unsigned long long

Obsah

rozsah SCHAR_MIN až SCHAR_MAX 0 až UCHAR_MAX SHRT_MIN až SHRT_MAX 0 až USHRT_MAX INT_MIN až INT_MAX 0 až UINT_MAX LONG_MIN až LONG_MAX 0 až ULONG_MAX LLONG_MIN až LLONG_MAX 0 až ULLONG_MAX

obvyklý rozsah -128 až 127 0 až 255 -32768 až 32767 0 až 65536 jako long nebo short

JJ

II

J

I


-2147483648 až 2147483647 0 až 4294967296

Zavřít Konec

Reálné typy typ float double long double

přesnost 7 desítkových číslic 15 desítkových číslic 19 desítkových číslic

rozsah ±1.1755 × 10−38 .. ± 3.4028 × 1038 ±2.2251 × 10−308 .. ± 1.7976 × 10308 ±3.3622 × 10−4932 .. ± 1.1897 × 104932


JJ

II

J

I


Standardní aritmetické konverze Při množství číselných typů je stanoveno, že při vyhodnocování aritmetického výrazu se automaticky provádějí následující standardní konverze (tento postup přesně platí pro binární operátory +, -, * a /, u ostatních operátorů je poněkud modifikován):


1. hodnoty typu signed char a short se převedou na typ int a 2. hodnoty typu unsigned char a unsigned short se převedou na typ unsigned; potom 3. je-li jeden z operandů typu long double, převede se druhý na tento typ a provede se operace pro tento typ 4. jinak je-li jeden z operandů typu double, převede se druhý na tento typ a provede se operace pro tento typ 5. jinak je-li jeden z operandů typu float, převede se druhý na tento typ a provede se operace pro tento typ 6. jinak je-li jeden z operandů typu unsigned long, převede se druhý na tento typ a provede se operace pro tento typ 7. jinak je-li jeden z operandů typu long, převede se druhý na tento typ a provede se operace pro tento typ 8. jinak je-li jeden z operandů typu unsigned, převede se druhý na tento typ a provede se operace pro tento typ

Obsah

JJ

II

J

I


9. jinak musí být oba operandy typu int, a provede se operace pro tento typ V normě podle K&R se navíc převáděly všechny hodnoty typu float na typ double. Kromě těchto implicitně prováděných konverzí lze konverzi vynutit operátorem změny typu: ( typ ) výraz. Příklad je v kapitole „Výpočty s celými číslyÿ.


JJ

II

J

I


Výpočty s celými čísly • Každý celočíselný typ reprezentuje omezený interval celých čísel • Pokud nedojde při výpočtu k překročení číselného rozsahu jsou výpočty přesné • Překročení číselného rozsahu se ale snad v žádné implementaci nekontroluje (to není vlastnost jazyka C, ale týká se to téměř všech programovacích jazyků)


JJ

II

J

I


/* K zadanému roku vypočítá datum velikonoc podle Gaussova vzorce */ #include <stdio.h> int main() { int r, k, pr, d, e, den;


printf("Rok: "); scanf("%d", &r); k=r/100; pr=k-k/4; d = (19*(r%19) + (15-(8*k+13)/25+pr)%30) % 30; e = (2*(r%4)+4*(r%7)+6*d+(4+pr)%7) % 7; den=22+d+e; if (d==29 && e==6) den-=7; if (d==28 && e==6 && r/19>10) den-=7; if (den>31) printf("Velikonoce: %d. 4. %d\n", den-31, r); else printf("Velikonoce: %d. 3. %d\n", den, r); }

JJ

II

J

I


/* * Pro zadané datum spočítá den v týdnu * (1=pondělí, 2=úterý, ... 6=sobota, 0=neděle) */ Úvodní strana

#include <stdio.h> int main() { int rok, mesic, den, p; printf("Zadej datum dd.mm.rrrr: "); if (scanf("%d.%d.%d", &den, &mesic, &rok)==3) { if (mesic<3) { mesic+=12; rok--; } p=(long)rok*365+rok/4-rok/100+rok/400+(306*(mesic+1))/10+den-1; printf("Den v týdnu: %d\n", (int) (p % 7)); } else { printf("Spatně zadané datum."); } }


JJ

II

J

I


Výpočet kořenů kvadratické rovnice Napíšeme program, který vypočítá kořeny kvadratické rovnice ax2 + bx + c = 0


Podle hodnoty diskriminantu D

Obsah

D = b2 − 4ac

JJ

II

J

I

musíme rozlišit tři případy Strana 29 z 89

jestliže D > 0 jestliže D = 0 jestliže D < 0

√ x1,2 = −b±2a D x1,2 = −b 2a √ −D −b x1,2 = 2a ± 2a i


(dvojnásobný kořen) Zavřít Konec

Budeme potřebovat tři reálné proměnné pro uložení koeficientů a, b, c. Aby nebylo nutné počítat diskriminant opakovaně, použijeme pro jeho uložení další proměnnou.

V jazyce C je nutné každou proměnnou deklarovat. Deklarace bude vypadat takto: double a, b, c, D; Úvodní strana

V programu budeme potřebovat podmíněný příkaz. Jeho syntaktický diagram vypadá takto: - else - příkaz

- if - ( - výraz - ) - příkaz Výraz bývá nejčastěji relační – porovnání s použitím jednoho z následujících operátorů:


JJ

II

J

I

Strana 30 z 89

== != < > <= >=

je rovno není rovno je menší než je větší než je menší nebo rovno je větší nebo rovno

V případě, že je výraz pravdivý, provede se příkaz uvedený za kulatou závorkou. Pokud by mělo být provedeno více příkazů, je nutné použít složený příkaz. Příkaz, který se má provést při


#include <stdio.h> #include <math.h> void main() { float a, b, c, D; printf("Program na výpočet kořenů kvadratické rovnice ax^2+bx+c=0\n\n"); printf("Koeficient a: "); scanf("%f", &a); printf("Koeficient b: "); scanf("%f", &b); printf("Koeficient c: "); scanf("%f", &c); printf("Rovnice %G.x^2 %+G.x %+G = 0\n", a, b, c); if (a==0) { if (b==0) { if (c==0) { printf("Rovnici vyhovuje každé x.\n"); } else { printf("Rovnice nemá řešení.\n"); } } else { printf("Lineární rovnice; řešení x = %G.\n", -c/b); }


JJ

II

J

I


} else { D=b*b-4*a*c; if (D>0) { printf("Řešení: x1 = %G, x2 = %G.\n", (-b+sqrt(D))/(2*a), (-b-sqrt(D))/(2*a)); } else if (D==0) { printf("Řešení: x1,2 = %G.\n", -b/(2*a)); } else { printf("Řešení: x1,2 = %G +- %Gi.\n", -b/(2*a), fabs(sqrt(-D)/(2*a))); } } }


JJ

II

J

I


Výpočet Ludolfova čísla π Napíšeme program, který vypočítá Ludolfovo číslo pí. Použijeme vzorec π 1 1 = arctg + arctg 4 2 3


Pro výpočet hodnoty funkce arctg použijeme Taylorův vzorec Obsah

x3 x5 x7 x9 arctgx = x − + + − + . . . (pro x < 1) 3 5 7 9

JJ

II

J

I

#include <stdio.h> #include <math.h>

Strana 33 z 89

void main() { int n; double moc2, moc3; double znam; double epsilon; double clen, suma;

Celá obrazovka

epsilon=1e-9; znam=1.0;

Zpět

Zavřít Konec

moc2=1.0/2.0; moc3=1.0/3.0; n=1; clen=moc2+moc3; suma=clen; while (fabs(clen)>epsilon) { n=n+2; znam=-znam; moc2=moc2/4.0; moc3=moc3/9.0; clen=znam/n*(moc2+moc3); suma=suma+clen; }


JJ

II

J

I

Strana 34 z 89

printf("Ludolfovo číslo: %.10lG\n", 4.0*suma); }


Výpočet faktoriálu #include <stdio.h> #include Úvodní strana

unsigned long factorial(unsigned long n) { unsigned long fnm1; if (n<=1) return 1UL; /* 1UL is 1 of type unsigned long */ fnm1=factorial(n-1); if (ULONG_MAX/n

JJ

II

J

I

Strana 35 z 89

int main() { unsigned long n, f; printf("Program na výpočet faktoriálu\n"); printf("Zadej číslo: "); if (scanf("%lu", &n)!=1) { fprintf(stderr, "Nebylo zadáno číslo!\n"); return 2; } printf("Počítám %lu!\n", n); f=factorial(n); if (f==0) {


fprintf(stderr, "Výsledek je příliš velký!\n"); return 1; } printf("%lu! = %lu\n", n, f); return 0; }


Problémem rekurzivního výpočtu faktoriálu je, že i když hlídám aritmetické přetečení, dojde k přetečení zásobníku dříve než k aritmetickému přetečení.

Obsah

JJ

II

J

I


Práce s logickými hodnotami Jazyk C nemá (na rozdíl od Pascalu) zvláštní typ pro logické hodnoty. Logické hodnoty často používáme, niž bychom je potřebovali někam ukládat: Úvodní strana

if (a>b) max=a; else max=b; if (max>0 && max<=10) ...


– && je logické „aÿ (konjunkce).

JJ

II

V jazyce C lze pro ukládání logických hodnot použít libovolný celočíselný typ:

J

I

Strana 37 z 89

int a_je_vetsi; a_je_vetsi = (a>b); if (a_je_vetsi) max=a; else max=b;


Jako hodnota „nepravdaÿ se v jazyce C používá 0, jako „pravdaÿ 1. Příkazy if a while a logické operátory &&, || (logické „neboÿ – disjunkce), a ! (negace) jsou benevolentnější – za hodnotu „pravdaÿ považují libovolnou nenulovou hodnotu.

Konec

Pravdivostní tabulka v jazyce C: a

b

a && b

a || b

!a

!b

0 0 nenula nenula

0 nenula 0 nenula

0 0 0 1

0 1 1 1

1 1 0 0

1 0 1 0


Logické operátory && a || v jazyce C mají dvě sympatické vlastnosti: • Mají správné priority – ve výrazu i>0 && i<=10 není nutné (na rozdíl od Pascalu) používat závorky. • V případě, že po vyhodnocení jednoho členu je zřejmé, jaká bude hodnota celého výrazu, zbývající členy se již nevyhodnocují (tzv. shortcircuit evaluation). Díky tomu je možné jednoduše zapisovat složené podmínky jako while (i<MAX_A && hodnota>a[i]) i=i+1;.

Obsah

JJ

II

J

I


Typ pole Pole je složený datový typ – proměnná typu pole obsahuje několik hodnot (prvků) téhož typu. Počet prvků pole se stanovuje při deklaraci. Jednotlivé prvky se vybírají pomocí indexu, který v jazyce C může být libovolného celočíselného typu a index prvního prvku je vždy 0. U pole lze projít všechny prvky pomocí cyklu. Pole může mít více rozměrů než jeden. Je dobrou praxí deklarovat horní meze všech polí pomocí konstant a tyto konstanty používat na všech místech, kde se jedná o horní mez pole:


JJ

II

J

I

#define MAXPRVKU 10 Strana 39 z 89

double pole[MAXPRVKU]; int i;


pole[0]=0.0; pole[MAXPRVKU-1]=1.0; pole[MAXPRVKU/2]=2.0;

Zavřít Konec

For cyklus Jazyk C má zajímavou syntaxi i sémantiku for-cyklu: Úvodní strana

for (výraz1; výraz2; výraz3) příkaz; Titulní strana

znamená přesně totéž co výraz1; while (výraz2) { příkaz; výraz3; }

Zapamatujte si, jak vypadá for cyklus přes všechny prvky pole:

Obsah

JJ

II

J

I


#define MAXPRVKU 10 Konec

double pole[MAXPRVKU]; int i; for (i=0; i<[MAXPRVKU; i++) pole[i]=0.0;

Podprogramy, funkce, procedury K čemu slouží Nejobvyklejší odpověď na otázku, k čemu slouží podprogramy, funkce nebo procedury, bývá „aby bylo možné určitou akci provádět na různých místechÿ. Tato odpověď nám však téměř vůbec nepomůže k tomu, abychom vytvářeli srozumitelné a pěkné programy. Pokud se budeme držet tohoto principu a čirou náhodou budeme mít napsat program, ve kterém se žádná činnost neprovádí vícekrát, bude výsledkem jedna, velmi dlouhá a nesrozumitelná funkce. Lidská mysl je schopna obsáhnout pouze objekty omezené složitosti. Proto je třeba při programování rozdělovat řešení složitých problémů na menší části, kterým je člověk schopen snadno porozumět. Tyto části se realizují pomocí podprogramů. Každý podprogram by měl řešit určitou dobře definovatelnou a definovanou úlohu.


JJ

II

J

I


HLAVNÍM DŮVODEM POUŽÍVÁNÍ FUNKCÍ JE ZLEPŠENÍ SROZUMITELNOSTI PROGRAMU Při programování (nebo při čtení cizího programu) je v každém stádiu důležité, co dělají jednotlivé podprogramy, ale ne jak to dělají (to je zajímavé až při bližším pohledu).

Konec

Proto jsou podprogramy prostředkem programové abstrakce. K snazšímu pochopení přispívají mnemotechnické názvy procedur a proměnných a rozumné komentáře, které popisují části programu z hlediska řešeného problému a ne z hlediska použitého programovacího jazyka. Úvodní strana

Podprogramy v jazyce C – funkce


V různých jazycích se používají různé názvy pro podprogramy; v jazyce Pascal se například podprogramy dělí na funkce (které vracejí hodnotu) a procedury (které hodnotu nevracejí). V jazyce C je rozlišování funkcí a procedur dosti uvolněné – každou funkci je možné vyvolat jako proceduru (pokud nezáleží na vrácené hodnotě). V jazyce C se obvykle podprogramům říká pouze funkce, i když lze vytvářet funkce, které nevracejí žádnou hodnotu (funkce typu void). Deklarace – sděluje překladači, jak funkce vypadá (jaké má jméno, hodnotu jakého typu vrací, kolik má parametrů a jaké jsou jejich typy) – funkci deklarujeme zapsáním její hlavičky Definice – definuje, co funkce dělá – obsahuje hlavičku a tělo funkce Použití – vyvolání funkce ve výrazu nebo příkazu Každá funkce může mít pouze jedinou definici. Deklarací může být více, ale

JJ

II

J

I


nesmí být v rozporu mezi sebou ani s definicí. Použití funkce by měla předcházet deklarace nebo definice (pokud nepředchází, doplní si překladač, že se jedná o funkci bez parametrů vracející typ int). Úvodní strana

V jazyce C musí být za jménem funkce vždy otvírací kulatá závorka (i když funkce nemá žádné parametry).


Definice funkcí nelze v jazyce C vnořovat. Funkční hodnota se v jazyce C vrací příkazem return hodnota;.

JJ

II

Každá funkce by měla mít co možná nejjednodušší interakci se svým okolím. Přesněji veškeré interakce s okolím by měly být prováděné pomocí parametrů.

J

I

Funkce, která mění i jiné hodnoty než své parametry, se nazývá funkce s postranními efekty (side effects). Pokud možno bychom se takovýmto funkcím měli vyhýbat, stejně jako funkcím, které jsou kromě parametrů ovlivňovány jinými hodnotami.


Typ ukazatel Ukazatele slouží jako odkazy na jiné proměnné. Zatímco běžná proměnná může během výpočtu měnit svoji hodnotu, proměnná typu ukazatel může ukazovat na různé proměnné (měly by být téhož typu, ale toto omezení lze v případě potřeby obejít). Zatímco ve standardním Pascalu lze ukazatele používat pouze pro odkazy na dynamicky vytvářené proměnné, v jazyce C je jejich použití mnohem širší – mohou ukazovat na libovolné proměnné včetně lokálních.

Deklarace proměnných typu ukazatel


JJ

II

J

I

Strana 44 z 89

Ukazatele se deklarují takto: typ *identifikátor;

Pro práci s ukazateli slouží unární operátory & a *. Operátor &objekt je získání adresy objektu – je-li objekt typu t, je výraz typu „ukazatel na tÿ, neboli *t. Operátor *ukazatel je dereference ukazatele – jeho hodnotou je proměnná, na kterou ukazatel ukazuje. Hodnota NULL – je zaručeno, že žádný ukazatel na některý objekt nemá hod-


notu NULL.

Porovnání operací s ukazateli v jazyce C a v Pascalu Úvodní strana

operace dereference ukázání na objekt prázdná hodnota alokace paměti uvolnění paměti přístup k položce

C

Pascal

*ptr &objekt NULL ptr=malloc(sizeof(typ)) free(ptr) ptr->item

ptr^ @objekt (pouze Turbo Pascal) nil new(ptr) dispose(ptr) ptr^.item


JJ

II

J

I


int i, j, k, l; int *p, *q, *r; p=&i; /* p ukazuje na i, lze provést i když i není inicializováno */ i=1; j=2; q=&j; /* q ukazuje na j */ r=q; /* r ukazuje tam, co q (tj. na j) */ *p=*q; /* p ukazuje nadále na i, ale tímto se do i uloží 2 */ p=NULL; /* p neukazuje nikam */ *p=*q; /* chybně p neukazuje nikam, nelze tam kam ukazuje něco uložit */ r=&k; /* r ukazuje na k */ *r=3; /* tam, kam r ukazuje dej 3, tj. do k */ p=r; /* O.K. p ukazuje na k */


JJ

II

J

I


Prohození obsahu proměnných void prohod(int *p1, int *p2) { int temp; temp=*p1; *p1=*p2; *p2=temp;

Zavřít Konec

}

Proměnná temp musí být skutečně typu int a ne int *. Pokud by byla typu int *, nebylo by možné do ni přiřadit hodnotu. Úvodní strana

#include <stdlib.h> #include <string.h>


int prohodcokoli(void *p1, void *p2, int size) { void *ptemp; ptemp=malloc(size); if (ptemp==NULL) return 0; memcpy(ptemp, p1, size); memcpy(p1, p2, size); memcpy(p2, ptemp, size); free(ptemp); return 1;

JJ

II

J

I


} Konec

Ukazatele a pole Identifikátor pole se chová jako ukazatel. Má typ „ukazatel na typ prvku poleÿ. Jeho hodnota je ukazatel na nultý prvek pole (první prvek v poli, který má index nula).

Úvodní strana

Přesto se pole a ukazatel od sebe liší:


• Identifikátor pole není l-hodnota – není možné do něj přiřadit hodnotu. • Pokud deklarujeme pole, máme skutečně prostor pro počet položek, který je uveden v deklaraci; pokud deklarujeme ukazatel, máme prostor pouze pro tento ukazatel; aby bylo možné ukládat hodnoty na místo, kam ukazatel ukazuje, je potřeba buď s ním někam ukázat: ptr=&proměnná; nebo alokovat místo: ptr=malloc(n*(sizeof(*ptr)));.

JJ

II

J

I


Algoritmus quicksort Pracuje na principu „rozděl a panujÿ – při třídění vzestupně jsou na začátek pole přemístěna malá čísla, na konec velká a na obě části zvlášť je znovu uplatněn stejný algoritmus. Opakuje se dokud část, která se má třídit, nemá méně než dva prvky – pak je jistě setříděná.


1

3 5

7 9

2

4 6

8 0 Obsah

1

3 5

0 9

2

4 6

8 7

JJ

II

1

3 5

0 6

2

4 9

8 7

J

I


Aritmetika ukazatelů Je-li p ukazatel a n celé číslo, pak výrazy p+n a p-n jsou výrazy typu ukazatel a mají hodnotu „ukazatel na prvek o n míst dáleÿ, resp. „ukazatel na prvek o n míst zpětÿ. Ukazují-li ukazatele p a q do téhož pole, je výraz p-q typu int a jeho hodnotou je počet prvků mezi ukazateli q a p.


Typ void * – slouží pro konverze ukazatelů. JJ

II

J

I


Funkce pro vstup a výstup Funkce pro vstup a výstup lze rozdělit na několik skupin: hlavičkový soubor operace otevření souboru vytvoření souboru zavření souboru posunutí v souboru je konec souboru? vstup znaku znaku návrat znaku řetězce bloku formátovaný výstup znaku znaku řetězce bloku formátovaný

stdio.h

stdio.h

conio.h

(gets) scanf stdout putchar fputchar puts printf

io.h

Úvodní strana

file handle

FILE fopen fopen fclose fseek feof stdin getchar fgetchar

curses.h

(initscr)

FILE getc fgetc ungetc fgets fread fscanf

klávesnice

klávesnice

getch getche ungetch cgets

getch

cscanf

scanw

FILE putc fputc fputs fwrite fprintf

obrazovka

obrazovka

putch

addch insch addstr

open creat close lseek eof

file handle


JJ

II

J

I


ungetch getnstr

Celá obrazovka

read

cputs

Zavřít

file handle

write cprintf

printw

Konec

Ve druhém sloupci tabulky jsou funkce pro práci se standardním vstupem a výstupem. O otevírání a zavírání standardního vstupu a výstupu se stará operační systém. Místo dalších chybějících funkcí lze použít příslušné funkce ze třetího sloupce, u kterých se na místě parametru typu FILE * použije stdin – standardní vstup, nebo stdout – standardní výstup. Funkce gets pro vstup řádku ze standardního vstupu by se rozhodně neměla používat, protože neumožňuje zadat maximální délku čteného řetězce. Díky tomu může dojít k přetečení použitého řetězce, které může mít za následek přepsání dalších proměnných, havárii programu a za určitých podmínek i ohrožení bezpečnosti operačního systému. Místo funkce gets používejte fgets. Ve třetím sloupci jsou funkce pro práci s libovolnými soubory používající vyrovnávací paměti (buffered input/output). Pokud program pracuje s jinými soubory než se standardním vstupem a výstupem, obvykle používá právě tyto funkce. Ve čtvrtém sloupci jsou funkce pro práci s obrazovkou a klávesnicí, které byly použity u překladačů firmy Borland pro OS MS-DOS. Mají jednoduchou podporu oken v textovém režimu, umožňují přemisťovat a zjišťovat pozici kursoru na obrazovce a mazat obrazovku. Jedná se o funkce převzaté z turbopascalské jednotky Crt. Jsou dostupné pouze pokud použitý překladač má knihovny pro zajištění kompatibility s překladači Borland. V OS Unix existuje pro podobný účel knihovna curses, resp. ncurses, která má ovšem poněkud jiné funkce a zcela jiné ovládání.


JJ

II

J

I


V pátém sloupci jsou funkce z knihovny curses, která umožňuje vytvářet okna v textovém režimu v Unixu. Její použití je poměrně komplikované. V posledním sloupci jsou funkce, které tvoří minimální nadstavbu nad službami pro práci se soubory, které poskytuje operační systém. Jako odkazy na soubory se používají malá celá čísla, tak zvané manipulátory (file handles), které vracejí funkce open a creat (funkce se skutečně jmenuje creat a ne create). Tyto funkce nepoužívají vyrovnávací paměti, proto jsou při práci s malými bloky málo efektivní. Při otevírání souboru je nutné stanovit způsob práce se souborem: zda se bude pouze číst, pouze zapisovat nebo obojí, zda se má připisovat na konec, zda má být existující soubor přepsán a konečně zda mají být konvertovány znaky \n (newline) na znaky používané pro ukončení řádku v příslušném operačním systému (při výstupu; při vstupu bude prováděna opačná konverze). Způsob práce se souborem stanovuje zvláštní parametr funkcí fopen a open. Druhý parametr funkce fopen udává způsob práce se souborem. Je to řetězec, který je složen z hodnot uvedených v jednotlivých částech následující tabulky:


JJ

II

J

I


r r+ w w+ a a+ t b jinak

hodnota parametru mode ve funkci fopen (read) otevřít existující soubor pro čtení otevřít existující soubor pro čtení a zápis (update) (write) vytvořit soubor pro zápis; existující soubor bude přepsán vytvořit soubor pro zápis a čtení (update); pokud soubor se zadaným jménem existuje, bude přepsán (append) otevřít soubor pro připisování na konec; pokud soubor neexistuje, bude vytvořen otevřít soubor pro připisování na konec a čtení; pokud soubor neexistuje, bude vytvořen otevřít v textovém režimu otevřít v binárním režimu otevřít v režimu určeném proměnnou fmode

Podobně funkce open má jako druhý parametr celé číslo, které je tvořeno logickým součtem konstant uvedených v jednotlivých částech následující tabulky, a které určuje způsob práce se souborem:


JJ

II

J

I


O O O O O O O O O O O O

RDONLY WRONLY RDWR NONBLOCK NDELAY SYNC APPEND CREAT TRUNC EXCL BINARY TEXT

příznaky pro access v open otevřít jen pro čtení otevřít jen pro zápis otevřít pro čtení a zápis neblokující přístup (pouze při práci s FIFO v Unixu) totéž jako O NONBLOCK výstupní funkce skončí až po fyzickém zápisu na zařízení před každým zápisem nastavit file pointer na konec souboru vytvořit soubor existující soubor bude při otevření zkrácen na délku 0 po dobu otevření nebude soubor moci otevřít jiný program otevřít v binárním režimu otevřít v textovém režimu

Při zpracování vstupu je někdy potřeba načíst (provést vstupní konverzi) číslo, které se nachází v již načtených datech. Pro tento účel lze použít funkci sscanf, která funguje podobně jako scanf, ale místo ze standardního vstupu čte ze řetězce. Obdobně pro výstup existuje funkce sprintf, které formátovaný výstup ukládá do řetězce a ne do souboru. Pro vstupní konverze existují i specializované funkce:


JJ

II

J

I


druh konverze konverze řetězec konverze řetězec konverze řetězec konverze řetězec konverze řetězec konverze řetězec konverze řetězec konverze řetězec

funkce → → → → → → → →

typ typ typ typ typ typ typ typ

integer long long long unsigned long unsigned long long float double long double

strtol strtoll strtoul strtoull strtof strtod strtold

funkce atoi atol atoll, atoq Úvodní strana Titulní strana

atof

Program pro výpis obsahu souboru na standardní výstup Ošetření všech chyb, ke kterým může dojít při vstupu a výstupu, bývá komplikované. Ovšem v situacích, kdy může dojít k chybě, by program měl testovat, zda k ní nedošlo, a pokud ano, měl by o ní srozumitelně informovat uživatele.

Obsah

JJ

II

J

I


#include <stdio.h> #include <errno.h> FILE *fp; char buffer[1000]; int code=0; int main(int argc, char *argv[])

Zavřít Konec

{ if (argc!=2) { fputs("Usage: typec filename\n", stderr); return 1; } Úvodní strana if (!(fp=fopen(argv[1], "rt"))) { fprintf(stderr, "Error opening file %s: %s\n", argv[1], strerror(errno)); Titulní strana return 2; } else { Obsah while (!feof(fp)) { JJ II if (!fgets(buffer, sizeof(buffer)-1, fp) && errno!=0) { fprintf(stderr, "Error reading file %s: %s\n", argv[1], strerror(errno)); J I code=2; break; Strana 57 z 89 } else { Zpět if (fputs(buffer, stdout)==EOF) { fprintf(stderr, "Error writing stdout: %s\n", strerror(errno)); Celá obrazovka code=3; break; Zavřít } Konec } } if (fclose(fp) && code==0) { /* This error shouldn’t happen */ fprintf(stderr, "Error closing file %s: %s\n", argv[1], strerror(errno)); code=2;

} /* Check whether flushing buffers doesn’t cause an error; it would be really bad luck if it does, but what if the stdout is redirected to a disk file, disk is just full and there is no space to write the contents of bufffers? */ if (fflush(stdout) && code==0) { fprintf(stderr, "Error flushing stdout: %s\n", strerror(errno)); code=3; } } return code; }


JJ

II

J

I

Strana 58 z 89

Načítání čísel


Pro třídicí program vytvoříme funkci, která načítá čísla typu double. Funkce bude vracet hodnotu 1, pokud bylo načteno číslo a 0 jinak:

Zavřít Konec

#include #include #include #include

<stdio.h> <stdlib.h> <string.h> "readdbl.h"

#define BUFLEN 80 char buffer[BUFLEN]; int readdouble(double *value) { double val; char *p; int status; int len; status=0; /* Nic neprecteno */ if (fgets(buffer, BUFLEN, stdin)!=NULL) { val=strtod(buffer, &p); if (p!=buffer) { *value=val; status=1; /* Cislo nacteno */ } /* Jeste docist zbytek radku, pokud nebyl docten */ len=strlen(buffer); while (len>0 && buffer[len-1]!=’\n’) { if (fgets(buffer, BUFLEN, stdin)==NULL) break; len=strlen(buffer); } } return status; }


JJ

II

J

I


S touto funkcí lze snadno napsat proceduru na přečtení předem neznámého počtu prvků do pole (maximální počet načtených prvků je samozřejmě omezen velikostí pole): #include <stdio.h> #include "rdwrarr.h" #include "readdbl.h" int readarray(double x[], int n) { int i; i=0; while (i

JJ

II

J

I


} Zavřít

void writearray(double *x, int n) { int i; for (i=0; i
Konec

Vazba programu na operační systém Jazyk C byl navrhován s jasnou představou, jakým způsobem má program komunikovat s operačním systémem. Činnost programu je možné ovlivnit pomocí parametrů, které se zadávají na příkazovém řádku za jménem programu. Naopak program při svém skončení informuje operační systém, jak byl úspěšný, pomocí tzv. návratového kódu.


Zpracování parametrů Jazyk C umožňuje elegantně číst parametry programu zadaná na příkazovém řádku při jeho spouštění. Parametry bývají často jména souborů, ale není to podmínkou. Pro zpřístupnění parametrů programu je nutné definovat funkci main jako funkci se dvěma parametry. První parametr musí být typu int, druhý typu char *[] (pole ukazatelů na znak). Jména parametrů mohou být libovolná, ale tradičně se používají jména argc a argv (jako argument count a argument values). Použití parametrů ilustruje následující ukázka: #include <stdio.h> int main(int argc, char *argv[])

JJ

II

J

I


{ int i; printf("Jméno programu: %s\n", argv[0]); printf("Počet parametrů: %d\n", argc-1); for (i=1; i<argc; i++) printf("Parametr %d: %s\n", i, argv[i]); return 5;


}

Návratový kód

Obsah

JJ

II

J

I

Strana 62 z 89

Funkce main by měla být typu int a její provádění by mělo končit příkazem return vracejícím celé číslo (případně je možné ukončit program v libovolné funkci voláním procedury exit, která má jako parametr celé číslo, jež bude také použito pro nastavení návratového kódu). Je zvykem, že vrácená hodnota informuje o úspěšnosti běhu programu. Hodnota 0 znamená běh bez chyb, nenulové hodnoty obvykle znamenají chyby, tím závažnější, čím je vrácená hodnota vyšší, ale konkrétní použití může být i odlišné. Ačkoli je hodnota typu int používají se hodnoty 0 až 255.


Funkce pro práci s řetězci Jsou definovány v hlavičkovém souboru string.h. Lze je rozdělit na funkce pro práci s ASCIIZ řetězci, funkce pro práci s ASCIIZ řetězci omezené délky, a funkce pro práci poli znaků. U funkcí z druhé a třetí skupiny se zadává délka nebo maximální délka řetězce; funkce z poslední skupiny nepovažují znak s kódem nula za konec řetězce. Operace zjištění délky vyplnění znakem zkopírování připojení na konec porovnání <, =, > porovnání, malá=velká porovnání, malá=velká vyhledání znaku vyhledání podřetězce

ASCIIZ řetězec strlen strset strcpy strcat strcmp stricmp strcmpi strchr strstr

řetěz. omez. délky

blok paměti

strnset strncpy strncat strncmp strnicmp strncmpi

memset memcpy memcmp memicmp memchr


JJ

II

J

I


Další funkce • memmove – Zkopíruje blok bytů, vypořádá se s překrýváním zdrojového a cílového bloku • memccpy – Zkopíruje blok bytů zakončený zadaným znakem zadané ma-

ximální délky • stpcpy – Zkopíruje řetězec, vrátí ukazatel na koncovou nulu v kopii • strdup – Naalokuje paměť na haldě a do ní zkopíruje řetězec • strrchr – Vrátí poslední výskyt zadaného znaku v řetězci nebo NULL • strspn – Vrátí délku počáteční části prvního řetězce, která obsahuje pouze znaky z druhého řetězce, strcspn – která neobsahuje žádný znak z druhého řetězce • strpbrk – Vyhledá první výskyt libovolného znaku z druhého řetězce v prvním řetězci • strtok – Postupně vrací části z prvního řetězce, které neobsahují žádný znak z druhého řetězce • strlwr – Převede velká písmena v řetězci na malá, strupr – malá na velká, strrev – malá na velká a velká na malá • strcoll – Porovná dva řetězce, bere v potaz národní zvyklosti podle nastavení setlocale • strxfrm – Transformuje řetězec tak, aby následné porovnání dvou transformovaných řetězců pomocí strcmp vrátilo stejnou hodnotu jako strcoll na původní řetězce • strerror – Vrátí textový popis chyby zadaného čísla


JJ

II

J

I


Oddělený překlad Oddělený překlad (samostatná kompilace) je prostředek, který usnadňuje vytváření rozsáhlých programů. Úvodní strana

• Program je rozdělen na logické celky – kompilační jednotky, moduly

Titulní strana

• Každá kompilační jednotka se překládá zvlášť

Obsah

• Jeden modul obsahuje obvykle definice datových struktur a funkcí, které s nimi pracují

JJ

II

• Program se sestavuje z jedné nebo několika kompilačních jednotek

J

I

• Větší množství přeložených kompilačních jednotek lze sloučit do knihovny • Pokud se změní pouze jedna kompilační jednotka, stačí přeložit pouze ji a znovu sestavit program • Na různých modulech mohou pracovat různí lidé • Některé moduly mohou být použity ve více programech (znovupoužitelnost)


Program je rozdělen na části, moduly (například modul pro vytváření menu, vstup údajů, zpracování údajů, grafický výstup na obrazovku, výstup na tiskárnu a práci se soubory). Každý modul je umístěn ve zvláštním zdrojovém souboru obsahující definice všech potřebných objektů (procedur, proměnných, konstant a typů). Každý zdrojový soubor se překládá samostatně. Aby objekty definované v jednom modulu mohly být používány v dalších, musí každý z těchto modulů obsahovat deklarace použitých objektů. V jazyce C je zvykem umísťovat tyto deklarace do tzv. hlavičkových souborů, které se vloží direktivou #include do všech zdrojových souborů, ve kterých se budou používat.


JJ

II

J

I


Rozdíl mezi definicí a deklarací: Definice skutečně vytvoří proměnnou (vyhradí pro ni místo) nebo proceduru (definuje, jaké budou příkazy v těle procedury). Deklarace pouze oznamuje, že existuje (to znamená „někde je definovánÿ) objekt s určitého jména, typu a dalších vlastností.


Následující příklad ukazuje jednoduché použití samostatně kompilovaných modulů. Souboru modul.c obsahuje definice proměnné x a procedury printx() pro tisk obsahu této proměnné.

Obsah

JJ

II

J

I

Strana 67 z 89

Soubor modul.c: #include "modul.h" int x;


void printx() { printf("%d\n", x); }

Souboru modul.h obsahuje deklarace objektů definovaných v modul.c. Tento soubor se pomocí direktivy #include vkládá, do každého souboru, ve kterém se používá sdílená proměnná x nebo procedura printx().

Soubor modul.h:


extern int x; Obsah

void printx();

Příklad programu, který používá objekty z modul.c.

JJ

II

J

I

Strana 68 z 89

Soubor program.c:


#include "modul.h" Zavřít

void main() { x=2; printx(); x++; printx(); }

Konec

Makra preprocesoru Jednou z funkcí preprocesoru je používání maker s parametry. Vhodně definovaná makra mohou značně zlepšit srozumitelnost programu. Úvodní strana

Makra s parametry se definují pomocí direktivy #define – stejně jako konstanty. Jméno makra je od #define odděleno alespoň jednou mezerou, bezprostředně za jménem je otevírací kulatá závorka, jeden nebo více parametrů oddělených čárkami a uzavírací kulatá závorka. Za další alespoň jednou mezerou následuje hodnota makra – text, ve kterém se mohou vyskytovat parametry. Je-li text makra dlouhý, lze jej rozdělit pomocí znaku obrácené lomítko a pokračovat na další řádku. Pokud se v textu programu vyskytne řetězec shodný se jménem makra následovaný argumenty v závorce, preprocesor dosadí (textově), argumenty z volání makra za argumenty z definice a místo volání makra vloží text z definice. Vzhledem k tomu, že hodnoty parametrů mohou být libovolné posloupnosti znaků (tedy libovolné výrazy), je nutné v textu makra uzavírat každý parametr do závorek, a totéž udělat i s celým textem makra (aby nedošlo k problémům způsobeným různou prioritou operátorů).


JJ

II

J

I


Použití maker – heapsort Následující příklad ukazuje, jak pomocí maker zpřehlednit třídicí algoritmus heapsort. V tomto algoritmu se na tříděné hodnoty pohlíží, jako by byly uspořádány do binárního stromu (s hodnotou v každém uzlu) tak, že hodnota otce každého uzlu je větší nebo rovna hodnotě obou jeho potomků. Algoritmus se skládá ze dvou částí: vytvoření heapu, a postupného odebírání největších prvků z heapu. Heap se vytváří postupným přidáváním prvků; jednoprvkový strom je vždy heap. Pokud přidáním dalšího prvku dojde porušení podmínky, je prvek prohozen se svým otcem, což může vyvolat potřebu dalšího prohození (otce s jeho otcem) atd. .


JJ

II

J

I

Strana 70 z 89

Odebírání prvků z heapu se provádí tak, že se odebere prvek z vrcholu a vloží se na první místo již setříděné části pole (setříděné pole se vytváří odzadu). Na jeho místo se dá nejpravější prvek z heapu, čímž se heap zmenší o jeden prvek. Prvek, který byl umístěn do vrcholu, může porušit podmínku pro heap, a pak je nutné jej prohodit s větším z jeho synů, atd. až prvek, který byl umístěn do vrcholu heapu, klesne tam, kde už neporušuje podmínku heapu. Pak se odebere další prvek atd. . Heap je realizován v poli tak, že vrchol je nultý prvek, a následují další vrstvy odshora, takže synové vrcholu jsou první a druhý prvek, synové levého syna vrcholu jsou třetí a čtvrtý prvek, synové pravého syna pátý a šestý prvek atd. .


Makra LEFT(i), RIGHT(i) a PARENT(i) vracejí po řadě index levého syna, pravého syna, resp. otce prvku, který má v poli index i. #include <stdio.h> Úvodní strana

#define LEFT(i) (2*(i)+1) #define RIGHT(i) (2*(i)+2) #define PARENT(i) (((i)-1)/2)


void heapsort (double a[], int n) {

JJ

II

int z, i; double temp;

J

I

Strana 71 z 89

/* Vytváření heapu; jednoprvkové pole je vždy heap */ for (z=1; z0 && temp>a[PARENT(i)]) { a[i]=a[PARENT(i)]; i=PARENT(i); } a[i]=temp; } /* Postupné odebírání vždy jednoho největšího prvku z heapu */


for (z=n-1; z>0; z--) { temp=a[z]; /* Posledni prvek zkusím umístit do kořene a bublat dolů */ a[z]=a[0]; /* Odebrání prvku; z je už za heapem */ i=0; /* Je-li některý z následníků větší, je třeba bublat dolů */ while (LEFT(i)temp || RIGHT(i)temp) { /* Který z následníků je větší? Oba existují, je-li RIGHT(i)

JJ

II

J

I


Knihovna conio.h • Pro práci s obrazovkou a klávesnicí v MS-DOSu. • Zavedeno v Turbo-C (analogie jednotky Crt z Turbo Pascalu). • Není standardní knihovnou jazyka C (např. v DJGPP je z důvodu kompatibility)


Funkce pro umístění kursoru a zjištění jeho souřadnic: void gotoxy(int _x, int _y); int wherex(void); int wherey(void);

JJ

II

J

I


x vodorovně, y svisle, (1,1) je levý horní roh obrazovky. Pokud je definováno okno, jsou souřadnice v rámci něj a relativní vůči němu. Funkci pro výpis a čtení znaku s echem posouvají kursor.


Podporuje jednoduchá okénka: void window(int _left, int _top, int _right, int _bottom); Úvodní strana

– definuje (neviditelný) obdélník na obrazovce, všechny funkce z conio.h, které pracují s obrazovkou používají tento obdélník. Při startu programu je okno přes celou obrazovku. Není žádná podpora pro obnovování překrytých částí oken apod. – lze použít gettext() a puttext().


JJ

II

J

I


Analogie běžných funkcí pro vstupy a výstupy: int putch(int _c); int cputs(const char *_str); int cprintf(const char *_format, ...); int getch(void); int getche(void); int ungetch(int); int kbhit(void); char * cgets(char *_str); int cscanf(const char *_format, ...);

/* /* /* /* /* /* /* /* /*

Výpis znaku */ Výpis řetězce */ Formátovaný výstup */ Vstup znaku (bez echa) */ Vstup znaku (s echem) */ Vrácení přečteného znaku */ Byla stisknuta klávesa? */ Vstup řetězce */ Formátovaný vstup */

Funkce cgets očekává v prvním bytu řetězce hodnotu udávající maximální délku načítaného řetězce (včetně koncové nuly), po návratu je v _str[1] skutečná délka načteného řetězce – na rozdíl od gets je bezpečná. Pokud se výpis dostane do pravého dolního rohu okna, obrazovka odskroluje o jeden řádek nahoru. Po nastavení proměnné _wscroll na 0 se scrollovat nebude.


JJ

II

J

I


Smazání okna a smazání řádku v okně od pozice kursoru k pravému okraji okna: void clrscr(void); void clreol(void);

Konec

Barvy: BLACK BLUE GREEN CYAN RED MAGENTA BROWN LIGHTGRAY

černá tmavě modrá zelená modrozelená červená fialová hnědá bílá (světle šedá)

#define BLINK

DARKGRAY LIGHTBLUE LIGHTGREEN LIGHTCYAN LIGHTRED LIGHTMAGENTA YELLOW WHITE

šedá světle modrá světle zelená světle modrozelená světle červená světle fialová žlutá jasně bílá

0x80 /* Přičíst k parametru funkce textcolor() pro blikání */


JJ

II

J

I


Nastavování barev: void void void void void void void void

textattr(int _attr); textcolor(int _color); textbackground(int _color); normvideo(void); highvideo(void); lowvideo(void); blinkvideo(void); intensevideo(void);

/* /* /* /* /* /* /* /*

Nastaví barvu písma i pozadí */ Nastaví barvu písma (spodní 4 bity + bit 7) */ Nastaví barvu pozadí (bity 4-6) */ Úvodní strana Nastaví barvy, které byly při startu */ Titulní strana Nastaví jasnější barvy písma */ Nastaví tmavší barvy písma */ Obsah Blikání */ Jasné barvy pozadí */ JJ II J

Scrollování textu v okně (uplatňuje se od řádku, na kterém stojí kursor, až do posledního řádku v okně):

I


void delline(void); /* Smaže řádek s kursorem, zbytek okna posune nahoru */ void insline(void); /* Vloží prázdný řádek, zbytek okna posune dolů */


Načtení nastavení hodnot knihovny conio.h (poloha a velikost okna, poloha a viditelnost kursoru, atd.): void gettextinfo(struct text_info *_r); Úvodní strana

struct text_info { unsigned char winleft; unsigned char wintop; unsigned char winright; unsigned char winbottom; unsigned char attribute; unsigned char normattr; unsigned char currmode; unsigned char screenheight; unsigned char screenwidth; unsigned char curx; unsigned char cury; };

/* /* /* /* /* /* /* /* /* /* /*

levý okraj okna */ horní okraj okna */ pravý okraj okna */ spodní okraj okna */ aktuální barevné atributy */ normální barevné atributy */ aktuální videorežim */ šířka obrazovky (znaků) */ výška obrazovky (řádků) */ x-ová pozice kursoru */ y-ová pozice kursoru */


JJ

II

J

I


Nastavení vzhledu kursoru: void _setcursortype(int _type); /* Nastavení vzhledu kursoru */ #define _NOCURSOR #define _SOLIDCURSOR #define _NORMALCURSOR

0 1 2

Konec

Nastavení textového režimu videoadaptéru (přičtením C4350 dojde k přepnutí na 50 řádků na VGA nebo 43 na EGA): void textmode(int _mode); /* Nastaví textový režim z následujících: */ enum text_modes { LASTMODE=-1, BW40=0, C40, BW80, C80, MONO=7, C4350=64 };


Nastavení počtu řádek na obrazovce (používají se zvláštní znakové sady s výškou znaku 8, 14 nebo 16 bodů): void _set_screen_lines(int _nlines);

Uložení, obnovení a kopie obdélníku na obrazovce (2 byty na pozici – první je zobrazený znak, druhý barevné atributy):

Obsah

JJ

II

J

I


int gettext(int _left, int _top, int _right, int _bottom, void *_destin); Zavřít int puttext(int _left, int _top, int _right, int _bottom, void *_source); int movetext(int _left, int _top, int _right, int _bottom, int _destleft, int _desttop); Konec

Deklarace složitých typů int *fnc[20](int n)

je totéž jako


int *((fnc[20])(int n));

pole dvaceti funkcí s parametrem typu int, které vracejí ukazatel na int, ale něco jiného než

Obsah

JJ

II

J

I

Strana 80 z 89

int (*fnc[20])(int n);

co je totéž jako


int (*(fnc[20]))(int n);

pole dvaceti ukazatelů na funkci, která má parametr typu int a vrací hodnotu typu int, a to je je něco jiného než

Konec

int (*fnc)[20](int n);

což je totéž jako int ((*fnc)[20])(int n);


ukazatel na pole dvaceti funkcí, které mají parametr typu int a vrací hodnoty typu int

Obsah

JJ

II

J

I


Vlastnosti proměnných, funkcí, návěští a dalších pojmenovaných entit • doba trvání (existence, duration) – jakou část doby běhu programu proměnná existuje • oblast platnosti (výskytu, scope) – kde ve zdrojovém textu je možné používat určitý identifikátor pro odkazování na týž objekt


• způsob spojování – za jakých podmínek znamenají dva stejné identifikátory tutéž věc

JJ

II

J

I

věci (proměnné) mohou být z hlediska doby trvání (duration) Strana 82 z 89

• statické – existují po celou dobu běhu programu; proměnné deklarované vně funkcí a proměnné deklarované uvnitř funkcí s klíčovým slovem static nebo extern • automatické – lokální proměnné funkcí (deklarované bez static i extern) a formální parametry funkcí; existují po dobu vyvolání funkce; je-li funkce vyvolána rekurzivně, existují ve více exemplářích • řízené (controled) – vznikají voláním malloc a zanikají voláním free (nebo ukončením programu); pokud se provede ptr=malloc(4), je řízená ta paměť, která byla alokována, ne proměnná ptr – ta na ni pouze ukazuje


způsob spojování (linkage): • žádný – každá oblast platnosti identifikátoru se vztahuje k jinému objektu; tento způsob spojování mají proměnné a deklarované uvnitř funkce; pokud jsou ale deklarovány s klíčovým slovem extern, mají interní linkage • interní – různé oblasti platnosti identifikátoru v jednom zdrojovém souboru se vztahují k jednomu objektu; proměnné deklarované vně funkcí mají interní linkage; pokud jsou ale deklarovány s klíčovým slovem extern, mají externí linkage • externí – různé oblasti platnosti identifikátoru v různých zdrojových souborech se vztahují k jednomu objektu


JJ

II

J

I


jmenné prostory Celá obrazovka

Objekt je identifikovatelná oblast paměti, která může obsahovat v čase proměnnou nebo konstantní hodnotu nebo sadu hodnot. (Objekt zde nemusí objektem ve smyslu objektově orientovaného programování.) Entita je procedura, návěští, typ anebo objekt ve smyslu uvedeném výše. L-hodnota je výraz, který je odkazem na objekt. Objekt může být konstantní, pak mluvíme o konstantní l-hodnotě. Na levé straně přiřazovacího příkazu musí být l-hodnota, která není konstantní.

Zavřít Konec

Program se skládá z jednoho nebo více zdrojových souborů, které se překládají samostatně. Oblast výskytu identifikátoru (scope) je souvislá část programu, ve které lze identifikátor použít pro přístup k jedné určité entitě. Úvodní strana

Různé entity mají různé oblasti výskytu. Oblast výskytu Titulní strana

blok mají identifikátory deklarované uvnitř bloku a parametry procedur (lokální identifikátory). Oblastí výskytu je u parametrů procedur hlavička procedury a blok, který je jejím tělem, u ostatních identifikátorů nejvnitřnější blok obklopující deklaraci. procedura mají návěští, která se deklarují uvedením návěští a dvojtečky před příkazem. Příkaz goto label ; lze použít pouze uvnitř procedury, kde je návěští label deklarováno. prototyp procedury mají parametry prototypů procedur. Oblast výskytu je omezena na příslušný prototyp (tj. seznam parametrů v deklaraci procedury).

Obsah

JJ

II

J

I


soubor mají identifikátory deklarované mimo všechny bloky (globální identifikátory), například identifikátory funkcí. Oblasti výskytu dvou různých entit označených týmž identifikátorem se mohou překrývat jestliže

• Identifikátory mají různé jmenné prostory (name space). • Identifikátory mají stejné jmenné prostory, ale oblast výskytu identifikátoru jedné entity je blok, procedura nebo prototyp procedury, který je vnořen do oblasti výskytu druhé entity, čímž dočasně zakrývá tuto druhou entitu. Jmenné prostory označují skutečnost, že identifikátory určitých entit si vzájemně nekonkurují, protože mohou být použity pouze v přesně stanovených disjunktních případech. Jednotlivé jmenné prostory: Návěští mohou být použity pouze v deklaraci návěští a v příkazu goto. Jména struktur, unionů a výčtových typů se používají vždy ve spojení struct ident, union ident nebo enum ident. Jména položek struktur nebo unionů musí být jednoznačná pouze v rámci jedné struktury nebo unionu. Kromě deklarace se používají pouze pro přístup k položce struktury nebo unionu, na pravé straně operátoru tečka (.) nebo šipka (->). Ostatní identifikátory proměnných, procedur, konstant a typů (typedef jména). Viditelnost identifikátoru (visibility) je rovna oblasti jeho výskytu zmenšené o vnořené oblasti výskytu téhož identifikátoru se stejným jmenným prostorem, kde je první identifikátor zakryt.


JJ

II

J

I


Trvání objektu (duration) je doba, po kterou objekt existuje. Rozeznáváme objekty s trváním statickým, které existují po celou dobu běhu programu. automatickým, které existují pouze po dobu provádění bloku, ve kterém mají výskyt. dynamickým, které se vytvářejí vyvoláním funkce (například malloc()) a existují až do svého zrušení vyvoláním další funkce (free()) nebo do konce běhu programu. Způsob spojování (linkage) entit rozhoduje o tom, zda dva výskyty entity s týmž identifikátorem budou považovány za odkaz na tutéž entitu. Rozeznáváme následující způsoby spojování:


JJ

II

J

I


externí – entity se stejným jménem a jmenným prostorem se považují za tutéž entitu ve všech souborech a knihovnách, ze kterých je sestavován program. interní – entity téhož jména, patřící do stejného jmenného prostoru se považují za tutéž entitu v rámci souboru v němž se vyskytují. žádný – každý výskyt je považován za jinou entitu. Pravidla pro určení způsobu spojování jsou dosti složitá.


Další třídy paměti • register – rada pro překladač, aby proměnnou umístil do registru; přístup k registrům je obvykle rychlejší než do paměti; překladač se touto radou může ale nemusí řídit (může do registru umístit i jinou proměnnou, než která je deklarována s register); na takto deklarovanou proměnnou nelze použít operátor získání adresy (&); lze použít pouze u automatických proměnných • auto – proměnná má být automatická; prakticky nemá žádný význam, lze použít pouze u proměnných, které už automatické jsou


JJ

II

J

I


Zacházení s proměnnými • const – hodnotu proměnné nelze (kromě inicializace) měnit: const double pi = 3.14159265358979; double r, plocha; scanf("%lf", &r); plocha=pi*r*r; printf("Plocha kruhu je %lG\n", plocha); pi=22.0/7.0;

Poslední příkaz způsobí při překladu chybu nebo alespoň výpis varování. • volatile – hodnota proměnné se může měnit i jiným způsobem než programem; překladač musí při každém použití skutečně pracovat s proměnnou; používat například pro hardwarové registry nebo sdílené proměnné


JJ

II

J

I


Použití typedef Jestliže deklarace obsahuje specifikátor typedef, není deklarovaný identifikátor proměnnou, ale typem. Takto deklarovaný identifikátor je možné použít v dalších deklaracích jako specifikátor typu: typedef unsigned char byte; typedef unsigned short word; byte b; word w;

– v prvním řádku je deklarován typ byte jako unsigned char, ve druhém typ word jako unsigned short; v dalších dvou řádcích jsou pomocí těchto nových typů deklarovány proměnné b a w. Použitím typedef lze zpřehlednit zejména používání složitějších typů:


JJ

II

J

I


struct listitem { struct listitem *next; int value; } titem, *pitem; pitem seznam; p1=malloc(sizeof(titem));

Konec

Jazyk C. středa 8:50 A3 úterý 14:20 HI3

Recommend Documents