Jazyk C stručný přehled

Transkript

1 Jazyk C stručný přehled J. Zděnek, 2004 Literatura: Herout,P.: Učebnice jazyka C. 3.vyd., Kopp, 2003 Herout,P.: Učebnice jazyka C. 2.díl, Kopp, 2002 Prinz,U.-Prinz,P.: C Pocket Reference. O Reilly, 2002 Kernighan,B.-Ritchie,D.: The C Programming Language.2 nd ed.1989 Müldner,T.: C for Java Programmers. Addison Wesley Johnson,M.P.: Programming Language C. 2003, Alonso,G.: Programming in C. ETH Zurich, C - opravdu stručný přehled *C - další informace AVT - Jazyk C - Stručný přehled 1 C Historie / 1 C navržen 1972 (Dennis Ritchie, AT&T, Bell Laboratories, USA) C ovlivněn: ALGOL 60 (1960) CPL (1963, Cambridge) BCPL (1967, Martin Richard) B (1970, Ken Thompson) do C z asembleru přepsán operační systém UNIX Kernighan & Ritchie prvni standard C (K&R Standard) ANSI C Standard (ANSI X3.159), známý jako ANSI C ISO C Standard (ISO/IEC 9899), vychází z C aktualizace C89 na ANSI C aktualizace C95 na ANSI C99 AVT - Jazyk C - Stručný přehled 2

2 C Historie / 2 Skupina programovacích jazyků s částečně podobnou syntaxí: C 1972, Dennis Ritchie, Bell Laboratories Procedurální jazyk C , Bjarne Stroustrup, Bell Laboratories Objektová podpora Java 1995, James Gosling, Sun Objektový C# Nedávno, Microsoft Objektová podpora AVT - Jazyk C - Stručný přehled 3 C - Charakteristika Univerzální programovací jazyk střední až nižší úrovně Strukturovaný (funkce + data) Zdrojový kód přenositelný (portable), překladač ne (je závislý na platformě) Rychlý, efektivní, kompaktní kód Pružný a výkonný, stabilní Podpora konstrukcí jazyka vysoké úrovně (funkce, datové struktury) Podpora operací blízkých assembleru (ukazatele, bitové operace, ) Slabá typová kontrola Málo odolný programátorovým chybám Dává velkou volnost programátorovi v zápisu programu Výhoda: dobrý programátor vytvoří efektivní, rychlý a kompaktní program Nevýhoda: špatný nebo unavený programátor pak nepřehledný program náchylný k chybám Použití: operační systémy, řídicí systémy, grafika, databáze, číslicové zpracování signálů (DSP), AVT - Jazyk C - Stručný přehled 4

3 C / C++ / Java C Rychlý, kompaktní, málo bezpečný Kompilovaný kód C++ Rychlý, málo bezpečný, velmi složitý Kompilovaný kód Java Bezpečná, elegantní ale pro některé aplikace pomalá Interpretovaný kód (bytecode) s možnou částečnou podporou kompilovaných částí (JIT) AVT - Jazyk C - Stručný přehled 5 C / Java Co je stejné nebo podobné v C je stejné (podobné) Program začíná funkcí main() Stavba funkcí / metod, Jméno funkce, formální parametry, návratová hodnota, vymezení těla funkce, vymezení bloku, vlastnosti lokálních proměnných (jsou v zásobníku), předávání primitivních typů parametrů hodnotou, return. Množina znaků pro konstrukci identifikátorů Primitivní typy proměnných se znaménkem (Java nezná proměnné bez znam.) char, short, int, long, float, double Aritmetické, logické, relační, bitové operátory Podmíněný příkaz if() / if() else Příkazy cyklů while(), do while(), for(;;), break, continue Programový přepínač switch(), case, default, break AVT - Jazyk C - Stručný přehled 6

4 C / Java Co C nemá C nemá: Interpret kódu (JVM) (C je kompilovaný) Objektovou podporu Třídy, objekty, zapouzdření, dědičnost, polymorfismus Jednotnou metodiku vytváření a použití strukturovaných proměnných referenční proměnná, new() Automatickou správu paměti Garbage collector Ošetření výjimek metodikou chráněných bloků try, catch, finally Velikost proměnných nezávislou na platformě Standardní podporu grafického uživatelského rozhraní GUI Standardní podporu řízení událostí (events, talkers, listeners) Standardní podporu webovských aplikací (aplety, síťové připojení) Standardní podporu (semi)paralelního zpracování úloh threads, multitasking, multithreading AVT - Jazyk C - Stručný přehled 7 C / Java Co C nemá nebo je jinak v C je jinak: C je kompilovaný jazyk Zdrojový kód je nezávislý (portable) na platformě (málo závislý) Spustitelný kód je závislý na platformě Členění programu na moduly, určení jejich vazeb (interface) Import knihoven (systémových i uživatelských) Určení viditelnosti proměnných (scope), modifikátory přístupu Určení doby života proměnných Předávání některých parametrů do funkcí Vytváření strukturovaných proměnných (mohou být i statické) Definování konstant Ošetření běhových chyb (run-time errors) odpovědný programátor, překladač nevynucuje Správa paměti (heap management) odpovědný programátor, malloc / free Práce s booleovskými proměnnými a řetězci (přímo boolean a String není) AVT - Jazyk C - Stručný přehled 8

5 C / Java Co je v C navíc nebo jinak v C je navíc: Preprocessor Vkládání hlavičkových souborů (header file) do zdrojového kódu Podmíněný překlad Makra #pragma doplňující příkazy závislé na platformě Linker spojování přeložených modulů a knihoven do spustitelného kódu struct a bitová pole (strukturované proměnné z různých prvků) union překrytí proměnných různého typu (sdílení společné paměti) typedef zavedení nových typů pomocí již známých typů sizeof určení velikosti proměnné (i strukturovaného typu) enum výčtové typy (množina číslovaných pojmenovaných konstant) Parametr funkce jako seznam proměnné délky Ukazatele (pointer) jako prostředek nepřímého adresování proměnných Jiné názvy i parametry funkcí ze standardních knihoven (práce se soubory, znaky, řetězci, matematické funkce,.) AVT - Jazyk C - Stručný přehled 9 C Struktura programu / 1 Program v C se skládá z následujících součástí: Příkazy preprocesoru (Preprocessor commands) Definice typů (type definitions) Prototypy funkcí (function prototypes) kde je uvedena deklarace: Jména funkce Vstupních parametrů Návratové hodnoty funkce Proměnné (variables) Funkce (functions) (v C je procedura funkce bez návratové hodnoty) AVT - Jazyk C - Stručný přehled 10

6 C Struktura programu / 2 Funkce v C mají tento tvar: Každý program musí obsahovat právě jednu funkci main() Všechny funkce (včetně main()) mají jednotný formát: typ_navrat_hodnoty jmeno_fce (parametry_fce) { lokalni promenne prikazy Uvnitř funkce nelze definovat lokální funkce (definice funkci nesmí být vnořené) Na formátování zdrojového textu překladači nezáleží. Formátování zlepšuje autorovi (i ostatním) čitelnost a potlačuje chyby. AVT - Jazyk C - Stručný přehled 11 Příklad programu v C: C Struktura programu / 3 #include <stdio.h> /* hlavickovy soubor (header) */ #define NASOBITEL 5 /* symbolicka konstanta */ double funkcenasobeni (double conasobit); /* deklarace funkce prototyp */ main() { double vysledek; /* lokalni promenna */ const double PI=3.14; /* lokalni konstanta */ printf ( Nasobeni\n ); /* vystup na obrazovku */ vysledek=funkcenasobeni (PI); /* volani funkce s parametry */ printf( %d * %d = %d\n,nasobitel,pi,vysledek); /* formatovany vystup */ double funkcenasobeni (double conasobit) /* definice funkce */ { double d; d=nasobitel*conasobit; return( d ); /* vystup hodnoty z funkce */ AVT - Jazyk C - Stručný přehled 12

7 C Model kompilace / 1 soubor2.h soubor1.c Header soubor3.c Source code Source code 1) Preprocessor Zdroj.kód C Zdroj.kód ASM 2) Compiler Assembly code 3) Assembler Object code soubor4.asm Source code soubor5.lib Libraries Knihovny 4) Linker Spustitelný kód Executable code AVT - Jazyk C - Stručný přehled 13 C Model kompilace / 2 Vytvoření spustitelného kódu (viz obr): 1) Preprocesor: Čte zdrojový kód v C Odstraní komentáře Upraví zdrojový text podle direktiv preprocesoru (řádky začínající #) Vloží do textu obsah jiného souboru #include. Odebere text vymezený direktivami podmíněného překladu Expanduje makra 2) Překladač C: Čte výstup z preprocesoru Kontroluje syntaktickou správnost textu Hlásí chyby a varování Generuje text v assembleru (když nejsou chyby) AVT - Jazyk C - Stručný přehled 14

8 C Model kompilace / 3 Vytvoření spustitelného kódu (viz obr): 3) Assembler: Čte výstup z překladače C Generuje relokovatelný object kód (kód s nevyřešenými odkazy mezi moduly) Přeloží případné moduly zapsané přímo v assembleru (mix programovacích jazyků) 4) Linker (spojovací program): Čte object kód všech zůčastněných modulů programu Připojí knihovní object moduly (přeložené dříve nebo dodané), Vyřeší odkazy mezi moduly Generuje spustitelný kód (zjednodušené) AVT - Jazyk C - Stručný přehled 15 C Komentář C používá dva způsoby označení komentáře: /* Toto je komentář */ /* Toto je rovněž komentář rozdělený na několik řádků */ // Toto je též komentář až do konce řádku /* Komentář nesmí být vnořený do jiného komentáře /* to je chybný zápis komentáře */ */ Preprocesor nahradí každý komentář jednou mezerou //.. tento způsob některé překladače nepodporují AVT - Jazyk C - Stručný přehled 16

9 C Soubor platných znaků (ASCII) / 1 C - základní soubor znaků: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m h o p q r s t u v x y z ! # % & ( ) * +, -. / : ; < = >? [ \ ] ^? _ { ~ Oddělovače (whitespace characters) space, horizontal tab, vertical tab, newline, form feed \0 - null char (koncový znak řetězce) AVT - Jazyk C - Stručný přehled 17 * C Soubor platných znaků (ASCII) / 2 C - základní soubor znaků (pokrač.): Řídicí znaky pro řízení výstupních zařízení (escape sequences) Escape sequence Výstup Escape sequence Výstup \a Beep (pípnutí) \ Znak \b Backspace \ Znak \f Form feed \? Znak? \n Newline \\ Znak \ \r Carriage return \o \oo \ooo ( \741 ) o=osmičkové číslice (octal dig) \t Horizontal tab \xh ( \x1008 ) h =šestnáctkové číslice (hex dig.) \v Vertical tab C - ostatní znaky: Mohou se použít v komentářích, řetězcích a znakových konstantách AVT - Jazyk C - Stručný přehled 18

10 * C Identifikátory C - pravidla pro volbu identifikátorů: Obsahuje A,..,Y,a,..,z,0,..,9 a znak _ (underscore) První znak není číslice Rozlišují se velká a malá písmena (case sensitive) Délka identifikátoru není omezena, ale pouze 31 prvních znaků je významných (může se lišit podle implementace) C - rezervovaná slova (keywords): Musí být zapsaná malými písmeny auto default float register struct volatile break do for return switch while case double goto short typedef char else if signed union const enum int sizeof unsigned continue extern long static void AVT - Jazyk C - Stručný přehled 19 C - celočíselné datové typy: * C Datové typy / 1 Typ Velikost [byte] Rozsah Použití char až +127 nebo 0 až 255 Znaky unsigned char 1 0 až 255 Malá čísla signed char až +127 Malá čísla int 2 nebo až nebo až Celá čísla unsigned int 2 nebo 4 0 až nebo 0 až Kladná celá čísla short až Celá čísla unsigned short 2 0 až Kladná celá čísla long až Velká celá čísla unsigned long 4 0 až Kladná celá čísla Velikost celočíselných typů určená implementací Vždy ale platí (v byte): char <= short <= int <= long Typ boolean není (až ANSI C99), =0 ->false,!=0 -> true AVT - Jazyk C - Stručný přehled 20

11 * C Datové typy / 2 C - reálná čísla (neceločíselné datové typy): Velikost reálných čísel určená implementací Většina překladačů se řídí standardem IEEE , potom jsou rozsahy reálných čísel dány následující tabulkou: Typ Velikost [byte] Rozsah (uveden pro kladná č.) Přesnost float 4 1.2E-38 až 3.4E+38 6 desítkových číslic double 8 2.3E-308 až 1.7E desítkových číslic long double E-4932 až 1.1E desítkových číslic C - typ void: void značí prázdnou hodnotu nebo proměnnou bez typu (jen ukazatelé) void funkce1 (.) - fukce bez návratové hodnoty (procedura) int funkce2 (void) - funkce bez vstupních parametrů void *ptr; - ukazatel bez určeného typu (viz dále) AVT - Jazyk C - Stručný přehled 21 C - 6 typů konstant: * C Konstanty / 1 Celočíselné (integer constants) Reálné Znakové Řetězcové Výčtové (floating constants) (character constants) (literal constants) (literály) (enumeration constants) (pojmenované prvky množiny) Symbolické (#define MAX 300) AVT - Jazyk C - Stručný přehled 22

12 * C Konstanty - celočíselné / 2 C - Formát celočíselné konstanty: Desítkový - nezačíná číslicí 0 (nula), 1024 Osmičkový - začíná číslicí 0 (nula), 012 Šestnáctkový - začíná znaky 0x nebo 0X (nula x), 0x7F8A číslice a,..,f (A,..,F) mohou být velká i malá pismena C - Typ celočíselné konstanty: Není-li určen explicitně, přiřadí se nejbližší dostatečně veliký typ Desítkové konst. - int, long, unsigned long Šestnáctkové a osmičkové - int, unsigned int, long, unsigned long Určí se explicitně znaky U nebo u (unsigned), L nebo l (long) jinak int Desítkově Osmičkově Šestnáctkově Typ xF int x7FFF int 10U 012U 0xAU unsigned int 16L 020L 0x10L long 27UL 0333ul 0x1BUL unsigned long AVT - Jazyk C - Stručný přehled 23 * C Konstanty - reálné / 3 C - Formát reálné konstanty: S řádovou tečkou 41.9 Mantisa a exponent 5.67E-3 // 5.67*10-3 nebo rovněž 5.67e-3 C - Typ reálné konstanty: Není-li určen explicitně, pak je - double Určí se explicitně znaky F nebo f - float L nebo l - long double V tabulce jsou všechny konstanty typu double E e+2 519E E2 12e e+4 3.7E e E-6 0.4e-5.4E-5 AVT - Jazyk C - Stručný přehled 24

13 * C Konstanty - znakové / 4 C - Formát znakové konstanty : Jeden nebo více znaků v jednoduchých apostrofech B, g, ab, 9 C - Hodnota znakové konstanty : Jednoznaková konstanta ma hodnotu odpovídajícího kódu znaku v ASCII kódu 0 ~= 48, A ~=65 Víceznaková konstanta - hodnota závisí na implementaci překladače C C - Typ znakové konstanty: Znaková konstanta je typu int Pozn: Řídicí znaky (escape sequences) mohou tvořit znakové konstanty \n AVT - Jazyk C - Stručný přehled 25 * C Konstanty - řetězcové (literály) / 5 C - Formát řetězcové konstanty (literálu) : Posloupnost znaků a řídicích znaků (escape sequences) uzavřená v uvozovkách Já jsem řetězcová konstanta! \n Pozn: Řetězcové konstanty oddělené pouze oddělovači (whitespace characters) jsou sloučeny do konstanty jediné. Já jsem řetězcová konstanta! \n se sloučí do Já jsem řetězcová konstanta! \n C - Typ řetězcové konstanty: Řetězcová konstanta je uložená v poli typu char (array of char) a zakončená znakem \0 Nazdar se uloží v poli typu char takto: N a z d a AVT - Jazyk C - Stručný přehled 26 r \0

14 * C Konstanty - výčtové (enum type) / 6 C - Formát výčtové konstanty : enum { CERVENA, MODRA, BILA, CERNA; pak CERVENA=0 a každý další prvek má hodnotu o jedničku vyšší enum { MALY=5, VETSI, VELKY, NEJVETSI pak MALY=5, VETSI=6 a každý další prvek má hodnotu o jedničku vyšší C - Typ výčtové konstanty: Výčtová konstanta je typu int AVT - Jazyk C - Stručný přehled 27 * C Konstanty - symbolické #define / 7 C - Formát symbolické konstanty #define: Konstanta se založí příkazem preprocessoru #define (je to makro bez parametrů, každé #define musí být na samostatné řádku) #define CERVENA 0 /* Zde muze byt komentar */ #define MODRA 1 / /Je zvykem jména konstant psát velkými písmeny #define BILA 2 Hodnotu konstanty je možné vyjádřit konstantním výrazem #define MAX_1 (100*5)-12 Symbolické konstanty mohou být vnořené #define MAX_2 MAX_1+30 AVT - Jazyk C - Stručný přehled 28

15 * C Výrazy a operátory / 1 C - Výraz se skládá z operátorů a operandů Nejjednodušší výraz tvoří jen konstanta, proměnná, volání funkce Výraz sám může být operandem Výraz má typ a hodnotu (pouze výraz typu void hodnotu nemá) Výrazzakončený středníkem je příkaz př. výrazy: 4*315 // typ int 1.0+sin(x) // typ double srand((unsigned)time(null)) // typ void (int*)malloc(count*sizeof(int)) // typ int* Ve výrazu s více operátory určuje postup výpočtu priorita operátorů, V případě operátorů se stejnou prioritou pak jejich asociativita (L->R zleva doprava, R->L zprava doleva) Postup výpočtu výrazu lze změnit použitím kulatých závorek AVT - Jazyk C - Stručný přehled 29 * C Operátory - priorita, asociativita / 2 C - Priorita a asociativita operátorů U operátorů se stejnou prioritou jsou jim operandy přiřazeny podle jejich asociativity Priorita Operátor Asociativita Priorita Operátor Asociativita 1 () [] -> L->R 9 ^ L->R 2! ~ (type) * & sizeof R->L 10 L->R 3 * / % L->R 11 && L->R L->R 12 L->R 5 << >> L->R 13?: R->L 6 < <= > >= L->R 14 = += -= *= /= %= &= ^= = <<= >>= R->L 7 ==!= L->R 15, L->R 8 & L->R AVT - Jazyk C - Stručný přehled 30

16 * C Operátory - počet operandů / 3 C - Operátory mají 1, 2 nebo 3 operandy Všechny unární operátory mají stejnou prioritu Znaky -, +, *, & jsou podle počtu operandů operátory unární nebo binární V C je jediný ternální operátor?: (otazník-dvojtečka)(conditional operator) Pořadí vyhodnocení operandů není definováno (mimo popsané případy jako ++x, x--, ) funkce1() + funkce2() // Ktera funkce bude volana // prvni neni definovano AVT - Jazyk C - Stručný přehled 31 C - Aritmetické operátory * C Operátory - aritmetické / 4 Operátor Význam Příklad Výsledek * Násobení x * y Součin x a y / Dělení x / y Podíl x a y % Dělení modulo x % y Zbytek po dělení x a y + Sčítání x + y Součet x a y - Odčítání x - y Rozdíl x a y + (unary) Kladné znam. +x Hodnota x - (unary) Záporné znam. -x Hodnota -x ++ Inkrementace ++x x++ x=x+1 před výpočtem výrazu s x Výpočet výrazu s x a následné x=x+1 -- Dekrementace --x x-- x=x-1 před výpočtem výrazu s x Výpočet výrazu s x a následné x=x-1 Operandy aritmetických operátorů - libovolný aritmetický typ Výjimka: % (zbytek po dělení) - jen operandy typu int AVT - Jazyk C - Stručný přehled 32

17 C - Přiřazovací operátory * C Operátory - přiřazovací / 5 Operátor Význam Příklad Výsledek = Jednoduché přiřazení x = y Přiřaď hodnodu y do x op= Složené přiřazení x +=y x op=y je ekvivalentní x = x op y, kde op je binární aritmetický nebo bitový operátor Levý operand musí být l-value (location-value, left-value) - tj musí představovat paměťové místo pro uložení výsledku. Jednoduché přiřazení - povolené operandy - dva operandy - aritmetického typu - dva operandy typu - struct nebo union (stejných typů) - dva operandy typu - pointer (stejného typu) nebo pravý operand=null nebo jeden pointer typu void Operandy různých typů se převedou na typ levého operandu Přiřazení se vyhodnocuje R->L (zprava doleva) Př: a=b=100; // stejné jako a=(b=100); AVT - Jazyk C - Stručný přehled 33 C - Relační operátory * C Operátory - relační / 6 Operátor Význam Příklad Výsledek < Menší než x < y 1 když x je menší než y, jinak 0 <= Menší nebo rovno x <= y 1 když x je menší nebo rovno než y, jinak 0 > Větší než x > y 1 když x je větší než y, jinak 0 >= Větší nebo rovno x >= y 1 když x je větší nebo rovno než y, jinak 0 == Rovná se x == y 1 když se x rovná y, jinak 0!= Nerovná se x!= y 1 když se x nerovná y, jinak 0 Výraz s relačními operátory (relace) je typu int Výsledek je 1 nebo 0 - s významem 1 ~ true, 0 ~ false Povolené operandy relace: - dva operandy aritmetického typu - dva ukazatele (pointers) shodného typu nebo jeden z nich NULL nebo typu void AVT - Jazyk C - Stručný přehled 34

18 C - Logické operátory: * C Operátory - logické / 7 Operátor Význam Příklad Výsledek && Logické AND x && y 1 když x ani y není rovno 0, jinak 0 Logické OR x y 1 když alespoň jeden z x, y není roven 0, jinak 0! Logické NOT! X 1 když x je roven 0, jinak 0 Logické operátory spojují výsledky relací do logického výrazu Povolené operandy: Aritmetické typy Typ pointer Výsledek je 1 nebo 0 - s významem 1 ~ true, 0 ~ false Ve výrazech s operátory && a se vyhodnotí nejdříve levý operand, pokud je pak výsledek známý, pravý operand se nevyhodnocuje (zkrácené vyhodnocování logického výrazu) AVT - Jazyk C - Stručný přehled 35 * C Operátory - bitové logické / 8 C - Bitové operátory (bitwise operators): Operátor Význam Příklad Výsledek & Bitové AND x & y 1 když x i y je rovno 1 (bit po bitu) Bitové OR x y 1 když alespoň jeden z x, y je 1 (bit po bitu) ^ Bitové XOR x ^ x 1 když pouze jeden z x, y je 1 (bit po bitu) ~ Bitové NOT ~ x 1 když x je rovno 0 (bit po bitu) << Posun vlevo x << y Posun x o y bitů vlevo >> Posun vpravo x >> y Posun x o y bitů vpravo Bitové operátory vyhodnocují operandy bit po bitu Operátory posunu (shift operators) posouvají celý bitový obraz o zvolený počet bitů vlevo nebo vpravo Při posunu vlevo - jsou uvolněné bity zleva - plněny 0 Při posunu vpravo - jsou uvolněné bity zprava - u čísel kladných nebo typu usigned - plněny 0 (logical shift right) - u čísel záporných - buď plněny 0 (logical shift right) - nebo plněny 1 (arithmetic shift rigth) (závisí na implementaci překladače) AVT - Jazyk C - Stručný přehled 36

19 * C Operátory - přístupu do paměti / 9 C - Operátory přístupu do paměti: Operátor Význam Příklad Výsledek & Adresa proměnné &x Konstantní pointer na x * Nepřímá adresa *p Proměnná nebo funkce adresovaná ukazatelem p [ ] Prvek pole x [ i ] *(x+i), prvek pole x s indexem i. Prvek struct / union s.x Prvek x struktury / unionu s -> Prvek struct / union p->x Prvek x struktury / unionu s adresovaný ukazatelem p Operandem operátoru & nesmí být - bitové pole a proměnná třídy register Operátor nepřímé adresy * - umožňuje přístup pomocí ukazatele (pointer) int a,*pa; // proměnná int a ukazatel na int pa=&a; // adresa a do pa *pa=45; // totez jako a=45 double a[10],*pa; // proměnná int a ukazatel na int pa=a; // adresa pole a[ ] do pa (neni tam &) *(pa+3)=12; // totez jako a[3] nebo pa[3] AVT - Jazyk C - Stručný přehled 37 * C Operátory - ostatní / 10 C - Ostatní operátory (nepatří do žádné z předchozích kategorií): Operátor Význam Příklad Výsledek ( ) Volání funkce f1(x,y) Zavolej funkci f1 s parametry x, y (type) Přetypování (cast) (int) x Změň typ x na int Sizeof Velikost prvku (byte) sizeof(x) Velikost x (v byte)?: Podmíněný příkaz x?y:z Když x!=0 pak y jinak z, Postupné vyhodnocení x, y Vyhodnoť nejdříve x pak y Operátor přetypování je možné použít - pouze na operandy skalárních typů Operandem sizeof( ) může být - jméno typu nebo výraz Podmíněný operátor?: (otazník-dvojtečka) max = x > y? x : y; je totéž jako: if (x > y) max=x; else max=y; AVT - Jazyk C - Stručný přehled 38

20 C - Přetypování (cast): * C změna typu (přetypování) / 1 Změna typu za běhu programu - přetypování Přetypování: - Explicitní - zapisuje programátor prom_noveho_typu = (novy_typ) prom_puvodniho_typu; int a; float x = (float)a; - Implicitní - provede překladač automaticky Pokud nový typ může reprezentovat původní hodnotu, přetypování ji vždy zachová AVT - Jazyk C - Stručný přehled 39 * C změna typu (přetypování) / 2 C - Přetypování (cast) pokrač.: Priorita typu int (integer promotion): - Operandy typů char, unsigned char, short, unsigned short a bitová pole mohou být použity všude tam, kde je povolený typ int nebo unsigned int. Takové operandy jsou automaticky přetypovány na int nebo unsigned int. - C vždy očekává hodnoty alespoň typu int. char c; x=c+ 0 ; // c (typu char) je před výpočtem přetypována na int Implicitní aritmetické konverze typu: - Pokud mají operandy binárních operátorů rozdílné typy i po konverzi na int (integer promotion) proběhne konverze podle typu který, leží více vpravo v následující tabulce (konverze neprobíhá pro operátory =, &&, ): Int unsigned int long unsigned long double long double - V přiřazení (=) je výsledný typ roven typu na levé straně - Ukazatel typu void může být přetypován na libovolný jiný typ ukazatele a naopak. AVT - Jazyk C - Stručný přehled 40 float

21 C příkazy, blok (složený příkaz) / 1 C - Příkaz: příkaz = výraz zakončený středníkem příkaz tvořený pouze středníkem = prázdný příkaz C - Blok (též složený příkaz): Blok = seznam deklarací + seznam příkazů Uvnitř bloku musí deklarace předcházet příkazy Začátek a konec bloku je vymezen složenými závorkami {.. Bloky mohou být vnořené do jiného bloku Vnořený blok může začínat kdekoliv uvnitř bloku Syntaxe bloku (vnořených bloků): { // Zacatek bloku deklarace prikazy { // Zacatek vnoreneho bloku deklarace prikazy // Konec vnoreneho bloku // Konec bloku AVT - Jazyk C - Stručný přehled 41 C - Blok a vnořený blok: C příkazy, blok / 2 { // Zacatek bloku 1 int i; // Deklarace double sum=0.0; for(i=0;i<10;i++) // Prikazy { // Vnoreny blok 2 sum+=i; // Prikazy if(i==5) { // Vnoreny blok 3 int j; // Deklarace sum+=2; // Prikazy for(j=0;j<100;j++) ; // Prazdny prikaz // Konec bloku 3 // Konec bloku 2 // Konec bloku 1 AVT - Jazyk C - Stručný přehled 42

22 C příkazy, řízení běhu programu / 3 C - Příkazy pro řízení běhu programu: Podmíněné větvení programu: - podmíněný příkaz - if ( ), if ( ) else - programový přepínač - switch ( ) Cykly: - for ( ) - while ( ) - do.while ( ) Nepodmíněné větvení programu: - continue - break - return - goto AVT - Jazyk C - Stručný přehled 43 C příkazy, podmíněný příkaz / 4 C - Podmíněný příkaz if( ) else, větvení programu do 2 směrů: if (vyraz) prikaz1; [else prikaz2;] Když je vyraz!= 0 provede se prikaz1 jinak prikaz2 Část else je nepovinná Podmíněné příkazy mohou být vnořené Př: max=0; if (x > y) max=x; Př: if (z == 200) { // if 1 if (x > y) max=x; // if 2 else max=y; // else 2 // else // max=0; // else 1 AVT - Jazyk C - Stručný přehled 44

23 C příkazy, programový přepínač / 5a C - Programový přepínač switch(), větvení programu do n směrů: switch (vyraz) prikaz; Hodnota vyraz je porovnána s n konstantními výrazy typu int (case konst_x:..) Všechny konst_x musí být navzájem různé Hodnota vyraz musí být celočíselná Pokud je nalezena shoda, program pokračuje od tohoto místa dál, dokud nenajde příkaz break nebo konec přikazu switch switch se opustí příkazem break Pokud se shoda nenajde, program pokračuje sekcí default (je nepovinná) Pokud se shoda nenajde a sekce default není zařazena, celý switch se vynechá Přikazy switch mohou být vnořené Sekce default nemusí být zařazena jako poslední (je to ale zvykem) AVT - Jazyk C - Stručný přehled 45 C příkazy, programový přepínač / 5b C - Programový přepínač switch() pokrač.: switch (command) // Zacatek prepinace { // case g : // Zacatek sekce 1 case G : akce1(); // break; // Konec sekce 1 case s : // Zacatek sekce 2 case S : akce2(); // break; // Konec sekce 2 case X : akce3(); // Zacatek sekce 3 break; // Konec sekce 3 default: chyba(); // Zacatek sekce default tiskninapovedu(); // break; // Konec sekce default // Konec prepinace AVT - Jazyk C - Stručný přehled 46

24 C příkazy, cyklus for( ) / 6a C - Příkaz cyklu for( ; ; ): for ([vyraz1];[vyraz2];[vyraz3]) prikaz; Cyklus for() používá řídící proměnnou a probíhá následovně - inicializace (jednou před začátkem cyklu) - test řídícího výrazu - aktualizace proměnných na konci každého běhu cyklu Uvedené činnosti definují výrazy1,2,3 v hlavičce cyklu Výrazy výraz1 a výraz3 mohou být libovolného typu výraz2 je řídící a musí být skalárního typu Libovolný z výrazů1,2,3 lze vynechat Po vynechání řídicího výrazu2 se cyklus bude provádět nepodmíněně Cyklus lze nuceně opustit příkazem break Část těla cyklu lze vynechat příkazem continue (od continue do konce těla) AVT - Jazyk C - Stručný přehled 47 C příkazy, cyklus for( ) / 6b C - Příkaz cyklu for( ; ; ) pokrač: #define DELAY 20 int i; for(i=delay;i>0;i--) // Hlavicka cyklu ; // Telo cyklu (zde prazdne) #define MAXCOUNT 50 #define MAXSUMA 110 int i,suma; for(i=0,suma=0;(i<maxcount) (suma>maxsuma);i++) { suma+=5; // Telo cyklu AVT - Jazyk C - Stručný přehled 48

25 C příkazy, cyklus for( ) / 6c C - Příkaz cyklu for( ; ; ) pokrač: for(;;) ; // Nekonecny cyklus #define MAXCOUNT 50 #define MAXSUMA 110 int i,suma=0; for(i=0;i<maxcount;i++) { if (i==10) continue; suma+=5; if (suma>maxsuma) break; // 1x vynech zbytek cyklu // Ukonci cyklus predcasne AVT - Jazyk C - Stručný přehled 49 C - Příkaz cyklu while( ): while (vyraz1) prikaz; C příkazy, cyklus while( ) / 7 Cyklus while() probíhá následovně - 1) vyhodnoť vyraz1, - 2) pokud je vysledek!=0 proveď příkaz, jinak ukonči cyklus - 3) pokračuj bodem 1) Řídící vyraz1 se vyhodnocuje na začátku cyklu, pokud je výsledek ==0 cyklus se neprovede ani jednou Řídící vyraz1 se musí aktualizovat v těle cyklu, jinak je cyklus nekonečný int i=10,suma=0; while (i > 0) { suma+=i; i--; // Aktualizace ridici promenne AVT - Jazyk C - Stručný přehled 50

26 C příkazy, cyklus do..while( ) / 8 C - Příkaz cyklu do while( ): do prikaz while vyraz1 ; Cyklus do..while() probíhá následovně - 1) proveď příkaz - 2) vyhodnoť vyraz1, - 3) pokud je vysledek ==0 ukonči cyklus, jinak pokračuj bodem 1) Řídící vyraz1 se vyhodnocuje na konci cyklu, tělo cyklu se vždy provede nejméně jednou Řídící vyraz1 se musí aktualizovat v těle cyklu, jinak je cyklus nekonečný int i=10,suma=0; do // Zavorky bloku {.. zde nepovinne suma+=i; i--; // Aktualizace řídící proměnné while(i > 0); AVT - Jazyk C - Stručný přehled 51 C příkazy, continue / 9 C - Příkaz návratu na řídicí výraz continue: continue; Příkaz continue lze použít pouze v těle cyklů - for() - while() - do..while() Příkaz continue způsobí vynechání zbylé části těla cyklu a nové vyhodnocení řídicího výrazu cyklu int i=10,suma=0; do i--; // Aktualizace řídící proměnné if(i == 4)continue; // 1x vynech zbytek cyklu suma+=i; while(i > 0) AVT - Jazyk C - Stručný přehled 52

27 C příkazy, break / 10 C - Příkaz nuceného ukončení cyklu break: break; Příkaz break lze použít pouze v těle cyklů - for() - while() - do..while() a v těle programového přepínače switch() Příkaz break způsobí opuštění těla cyklu nebo těla switch(), program pokračuje prvním následujícím příkazem int i=10,suma=0; while (i > 0) { if(suma > 5)break; // Nucene opusteni cyklu suma+=i; i--; // Aktualizace ridici promenne AVT - Jazyk C - Stručný přehled 53 C - Příkaz ukončení funkce return: return vyraz; C příkazy, return / 11 Příkaz return lze použít pouze v těle funkce return ukončí funkci, vrátí návratovou hodnotu funkce určenou hodnotou vyraz a předá řízení volající funkci Příkaz return lze použít v těle funkce vícekrát U funkce typu void f1() nahrazuje uzavírací závorka těla funkce příkaz return int maxplusdve(int a, int b) { if(a > b) return(a+2); // Vystup z funkce (zavorky nepovinne) return(b+2); // Vystup z funkce AVT - Jazyk C - Stručný přehled 54

28 * C příkazy, goto / 12 C - Příkaz nepodmíněného lokálního skoku goto: goto navesti; Příkaz goto lze použít pouze v těle funkce Cíl skoku musí ležet uvnitř stejné funkce (lokální skok) goto předá řízení na místo určené návěštím navesti Skok goto nesmi směřovat dovnitř bloku, který je vnořený do bloku, kde je goto umístěno int hledejmax(int *p) { for(...) for(...) { if(...)goto error; return(...); error: return(...); // Ven z vnitrniho bloku // Cil skoku uvnitr funkce AVT - Jazyk C - Stručný přehled 55 * C proměnné, deklarace, definice / 1 C - Deklarace vs. Definice: Deklarace určuje interpretaci a vlastnosti identifikátoru(ů) Definice je deklarace včetně přidělení paměti (memory allocation) proměnným, konstantám nebo funkcím C - Syntaxe deklarace: [specifikator_pametove_tridy] typ D1 [,D2, ]; kde: - specifikator_pametove_tridy - extern, static, auto, register -typ -primitivní typy (char,int, ), void, enum, struct, union, typedef name (+ const, volatile, short, long, unsigned) - D1 [,D2, ] - seznam deklarátorů - jednoduchý deklarátor: identifikátor + počáteční_hodnota (nepovinná) - složený deklarátor identifikátor + počáteční_hodnota+symboly *, [ ], ( ) (pointer, array, function) AVT - Jazyk C - Stručný přehled 56

29 * C proměnné, deklarace, definice / 2 C - Přiklady deklarace proměnných: - jednoduché deklarace char znak; int i,j,k; unsigned int suma=0; const int k1=250; static double rychlost,zrychleni; extern unsigned char status; // +inicializace // +konstanta - složené deklarace int pole[30]; unsigned int polea[]={10,20,30,40; char s1[]= Ahoj ; char s2[5]={ A, h, o, j, \0 ; double da[2][3]; char *sptr; // jednorozm.pole // +inicializace // +inicializace // +inicializace // dvourozm.pole // ukazatel (pointer) AVT - Jazyk C - Stručný přehled 57 * C proměnné, paměťová třída / 3a C - Deklarace, definice - umístění ve zdrojovém kódu: Mimo těla funkcí (tj mimo všechny bloky) Na začátek bloku {. C - Proměnná musí být deklarována dříve než se použije: C - Pamětová třída proměnné (Storage Class): Paměťová třída definuje: Životnost proměnné (storage duration) během provádění programu Viditelnost proměnné (scope) z různých míst daného modulu programu Viditelnost proměnné (linkage) z ostatních modulů programu Pozn: zde modul programu=samostatně překládaný zdrojový soubor Paměťová třída je definována: Polohou deklarace proměnné v modulu programu Specifikatorem_paměťové_třídy (storage class specifier) (auto, register, static, extern) AVT - Jazyk C - Stručný přehled 58

30 * C proměnné, paměťová třída / 3b C - Životnost proměnné (storage duration): statická - vytvoření - jednou na začátku běhu programu - zrušení - po ukončení programu - zajistí - překladač + [static] - inicializace - explicitní nebo automatická na 0 / NULL. dočasná - vytvoření - automaticky vždy při vstupu programu do bloku { - zrušení - automaticky vždy po ukončení bloku - zajistí - překladač + [auto] - inicializace - explicitní nebo nedefinovaná!! Pozn: proměnné se nazývají automatické a zakládají se v zásobníku. volitelná - vytvoření - na žádost programátora za běhu programu - zrušení - na žádost programátora za běhu programu - zajistí - programátor voláním funkcí pro správu paměti - inicializace - explicitní nebo nedefinovaná!! Pozn: proměnné se nazývají dynamické a přidělují se z haldy (heap) AVT - Jazyk C - Stručný přehled 59 * C proměnné, paměťová třída / 3c C - Viditelnost proměnné (scope) v modulu (souboru): Globální v modulu - zajistí se - polohou deklarace v modulu + static Lokální v bloku {. - zajistí se - polohou deklarace v bloku { Pozn: viz následující příklady C - Viditelnost proměnné (linkage) v ostatních modulech (celý program): Globální v programu - zajistí se - polohou deklarace v bloku + [extern] Lokální v modulu - zajistí se - polohou deklarace v bloku + static Pozn: viz následující příklady AVT - Jazyk C - Stručný přehled 60

31 * C proměnné, paměťová třída / 3d C - Specifikátory paměťové_třidy (Storage Class Specifiers - SCS): SCS Auto Register static extern Význam Definuje proměnnou jako dočasnou (automatickou). Lze použít jen pro proměnné deklarované uvnitř funkce. Implicitní nastavení je auto Doporučuje překladači umístit proměnnou do registru procesoru (rychlost přístupu). Ten nemusí vyhovět (nemá-li volné registry). Jinak jako proměnné auto. Deklaruje proměnnou jako statickou uvnitř bloku {... Vně bloku (kde je proměnná implicitně statická) omezuje její viditelnost na modul. Rozšiřuje viditelnost statických proměnných z modulu na celý program Pozn: v deklaraci proměnné lze uvést vždy jen jeden SCS AVT - Jazyk C - Stručný přehled 61 * C proměnné, paměťová třída / 3e C - Životnost a viditelnost proměnných: LOKÁLNÍ V BLOKU LOKÁLNÍ V MODULU GLOBÁLNÍ V PROGRAMU int i; extern int i; static int max1=500; static int max1=200; extern int j; int j; int funkce1(int,int); int funkce1(int x, int y) void main(void) { { int a1; int test; int a2=30; test=funkce1(4,max1); static int a3=50; //test=funkce2(i); //nelze { Funkce3(); { int b1; b1=funkce2(4); STATICKÁ static void funkce3(void) { char c= A ; static int funkce2(int m)... {... AVT - Jazyk C - Stručný přehled 62

32 C proměnné, pole (array) / 4a C - Pole (array): Pole je množina prvků (proměnných) stejného typu K prvkům pole se přistupuje pomocí pořadového čísla prvku (indexu) Index musí být celé číslo (konstanta, proměnná, výraz) Index prvního prvku je vždy roven 0 Prvky pole mohou být proměnné libovolného typu (i strukturované) Pole může být jednorozměrné i vícerozměrné (prvky pole jsou opět pole) Definice pole určuje: - jméno pole - typ prvku pole - počet prvků pole Prvky pole je možné inicializovat Počet prvků statického pole musí být znám v době překladu Prvky pole zabírají v paměti souvislou oblast Velikost pole (byte) = počet prvků pole * sizeof (prvek pole) C - nemá proměnnou typu String, nahrazuje se jednorozměrným polem z prvků typu char. Poslední prvkek takového pole je vždy \0 (null char) C - nekontroluje za běhu programu, zda vypočítaný index je platný AVT - Jazyk C - Stručný přehled 63 C - Deklarace pole (array): char polea [10]; int poleb[3][3]; Uložení v paměti C proměnné, pole (array) / 4b // jednorozmerne pole z prvku char // dvourozmerne pole z prvku int poleb[0][0],[0][1],[0][2],[1][0],[1][1],[1][2],[2][0],[2][1],[2][2], C - Inicializace pole: double x[3]={0.1,0.5,1.3]; char s[]= abc ; char s1[]={ a, b, c, \0 // totez jako abc int ai[3][3]={{1,2,3{4,5,6{7,8,9; char cmd[][10]={ Load, Save, Exit ;// druhy rozmer nutny C - Přístup k prvkům pole: ai[1][3]=15*2; AVT - Jazyk C - Stručný přehled 64

33 C proměnné, ukazatel (pointer) / 5a C - Ukazatel (pointer): Ukazatel je proměnná obsahující adresu jiné proměnné (nepřímá adresa) Ukazatel má též typ proměnné na kterou může ukazovat - ukazatel na char - ukazatel na int atd. Ukazatel může být též bez typu (void), pak může obsahovat adresu libovolné proměnné. Její velikost pak nelze z vlastností ukazatele určit Neplatná adresa v ukazateli má hodnotu konstanty NULL C za běhu programu nekontroluje zda adresa v ukazateli je platná Adresa proměnné se zjistí adresovým operátorem & K proměnné na kterou ukazatel ukazuje se přistoupí operátorem nepřímé adresy * (hvězdička) Ukazatel může obsahovat též adresu funkce (ukazatel na funkci) Pomocí ukazatele na funkci lze funkci volat, včetně předání parametrů Pomocí ukazatele lze předávat parametry funkci odkazem (call by reference) (standardní metoda v C pro ostatní případy je volání hodnotou (call by value)) AVT - Jazyk C - Stručný přehled 65 C proměnné, ukazatel (pointer) / 5b C - Ukazatel (pointer) pokrač: adresa hodnota adresa hodnota int x,y; int *px,*py; px=null; px=&x; x=3; y=*px; py=px; *py=10; px px px NULL px x 3 x x x px y 3 py x 3 py x 10 AVT - Jazyk C - Stručný přehled 66

34 * C proměnné, ukazatel (pointer) / 5c C - Ukazatel (pointer) pokrač: adresa hodnota adresa hodnota int x; int *px int **ppx; x=1; px=null; ppx=null; px=&x; ppx=&px; **ppx=6; *px=10; px x 1 pp NULL x 1 pxx NULL x 1 px x 1 ppx x 1 ppx x 6 px x 10 AVT - Jazyk C - Stručný přehled 67 C proměnné, ukazatel (pointer) / 5d C - Ukazatel (pointer) - aritmetické operace: Povolené aritmetické operace s ukazateli: pointer + integer pointer - integer pointer1 - pointer2 (musí být stejného typu) C - Ukazatel na pole (pointer to array): Aritmetické operace jsou užitečné když ukazatel ukazuje na pole Jméno pole je konstantní ukazatel na počátek pole (na prvek a[0]) Aritmetické operace s ukazatelem na pole zajistí správný výpočet, z typu ukazatele se zjistí velikost prvku pole a ukazatel se posune o (pocet_prvku*velikost_prvku) int a[10],y; // a[] pole typu int int *px; // px ukazatel na int px=a; // Adresa a[0] do px px++; // px ukazuje na a[1] y=*(px+5); // do y hodnotu y a[5] px=&a[3]; // px ukazuje na a[3] AVT - Jazyk C - Stručný přehled 68

35 C proměnné, ukazatel (pointer) / 5e C - Ukazatel na pole (pointer to array) pokrač: V složitějších deklaracích ukazatelů mohou být nezbytné závorky double a[10]; // Pole z prvku double double (*pa)[10]; // Ukazatel na pole z 10-ti prvku double double *pa[10]; // Pole 10-ti ukazatelu na double C - Ukazatel na char a práce s řetězci: // Ukazatel na string char *s; // Ukazatel na char s= Ja jsem string ; // s ukazuje na prvni znak retezce C - Ukazatel na funkci: void funkce1(int x); // Prototyp funkce void (*pfnc)(int x); // Ukazatel na funkci s parametrem int int max=200; pfnc=funkce1; // Adresa funkce1 do ukazatele pfnc (*pfnc)(max); // Volani funkce1 pomoci ukazatele AVT - Jazyk C - Stručný přehled 69 C proměnné, struktura (struct) / 6a C - Struktura (struct): Struktura je množina prvků (proměnných), které nemusí být stejného typu Skladba struktury je definovaná uživatelem jako nový typ sestavený z již definovaných typů K prvkům struktury se přistupuje tečkovou notací K prvkům struktury je možné přistupovat i pomocí ukazatele na strukturu operátorem -> Struktury mohou být vnořené Pro struktury stejného typu je definována operace přiřazení struct1=struct2 (pro proměnné typu pole přímé přiřazení není definováno, jen po prvcích) Struktury (jako celek) nelze porovnávat relačním operátorem == Struktura může být do funkce předávána hodnotou i odkazem Struktura může být návratovou hodnotou funkce AVT - Jazyk C - Stručný přehled 70

36 C proměnné, struktura (struct) / 6b C - Struktura (struct) - sablona (tag): struct Tid{ // <==== Tid=jmeno sablony (tag) char jmeno[20]; // Prvky struktury, pole char adresa[50]; // - - pole long int telefon; // - - int ; struct Tid sk1,skavt[20]; // struktura, pole struktur struct Tid *pid; // ukazatel na strukturu sk1.jmeno= Jan Novak ; // teckova notace sk1.telefon=123456; skavt[0].jmeno= Jan Novak ; // prvek pole skavt[3].telefon=123456; pid=&sk1; // do pid adresa struktury pid->jmeno= Jan Novak ; // odkaz pomoci -> pid->telefon=123456; (*pid).jmeno= Jan Novak ; // odkaz pomoci * (*pid).telefon=123456; AVT - Jazyk C - Stručný přehled 71 * C proměnné, struktura (struct) / 6c C - Struktura (struct) - nový typ (typedef): typedef struct { // <==== Pomoci Typedef char jmeno[20]; // Prvky struktury, pole char adresa[50]; // - - pole long int telefon; // - - int Tid,*Tidp; Tid sk1,skavt[20]; // struktura, pole struktur Tidp pid; // ukazatel na strukturu sk1.jmeno= Jan Novak ; // teckova notace sk1.telefon=123456; skavt[0].jmeno= Jan Novak ; // prvek pole skavt[3].telefon=123456; pid=&sk1; // do pid adresa struktury pid->jmeno= Jan Novak ; // odkaz pomoci -> pid->telefon=123456; (*pid).jmeno= Jan Novak ; // odkaz pomoci * (*pid).telefon=123456; AVT - Jazyk C - Stručný přehled 72

37 * C proměnné, struktura (struct) / 6d C - Struktura (struct) - inicializace: struct Tid{ // <==== Tid=jmeno sablony (tag) char jmeno[20]; // Prvky struktury, pole char adresa[50]; // - - pole long int telefon; // - - int ; struct Tid sk1={ Jan Novak, Na kopecku 23, ; AVT - Jazyk C - Stručný přehled 73 * C proměnné, sdílená paměť (union) / 7 C - Sdílená paměť (union): Union je množina prvků (proměnných), které nemusí být stejného typu Prvky unionu sdílejí společně stejná paměťová místa (překrývají se) Velikost unionu je dána velikostí největšího z jeho prvků Skladba unionu je definovaná uživatelem jako nový typ sestavený z již definovaných typů K prvkům unionu se přistupuje tečkovou notací union Tnum{ // <==== Tnum=jmeno sablony (tag) long n; double x ; union Tnum nx; // nx - promenna typu union Tnum nx.n= l; // do n hodnota long nx.x=2.1456; // do x hodnota double (prekryva n) AVT - Jazyk C - Stručný přehled 74

38 C funkce / 1 C - Funkce (function): C je modulární jazyk a funkce je jeho hlavním stavebním blokem Každý program v C obsahuje minimálně funkci main() Běh programu začíná na začátku funkce main() C používá prototypu funkce k deklaraci informací nutných pro překladač, aby mohl správně přeložit volání funkcí i v případě, že definice funkce je umístěna dále v kódu modulu nebo je jiném modulu Prototyp funkce (function prototype) se skládá pouze z hlavičky funkce, (odpovídá interface v Javě) Definice funkce obsahuje hlavicku funkce a její tělo Syntaxe definice funkce: typ_navratove_hodnoty jmenofunkce(seznam_parametru) { definice_lokalnich_promennych seznam_prikazu Parametry se do funkce předávají hodnotou (call by value), parametrem může být i ukazatel (pointer). Ten pak dovolí předávat parametry i odkazem. AVT - Jazyk C - Stručný přehled 75 C funkce / 2 C - Funkce (function) pokrač: C nepovoluje funkce vnořené do jiných funkcí (lokální funkce ve funkci) Jména funkcí jsou implicitně extern, a mohou se exportovat do ostatních modulů (samostatně překládaných souborů) Specifikátor static před jménem funkce omezí viditelnost jejího jména pouze na daný modul (lokální funkce modulu) Formální parametry funkce jsou běžné lokální proměnné inicializované skutečnými parametry při volání funkce C dovoluje rekurzi, lokální proměnné jsou pro každé jednotlivé volání zakládány znovu (v zásobníku). Kód funkce v C reentrantní (reentrant). Funkce nemusí mít žádné vstupní parametry, zapisuje se funkcex(void) Funkce nemusí vracet žádnou funkční hodnotu, pak je návratový typ void (je to procedura) AVT - Jazyk C - Stručný přehled 76

39 C funkce / 3 C - Funkce (function) pokrač: int max(int a,int b); // Prototyp funkce int i=10,j=20,k; void main(void) { // Zacatek programu k=max(i,j);... // Definice funkce int max(int a, int b) // Formalni parametry a,b jsou { // tez lokalni promenne if(a > b)return(a); return(b); AVT - Jazyk C - Stručný přehled 77 * C funkce / 4 C - Funkce (function) pokrač: double sumareciprocn(int n); double vysledek; // Prototyp funkce void main(void) { // Zacatek programu vysledek=sumareciprocn(50);... // Soucet rady 1/n double sumareciprocn(int n) // Definice funkce { double x; int i; if(n <= 0)return(0); for(x=1,i=1;i < n; i++) x += 1/((double)i); return(x); AVT - Jazyk C - Stručný přehled 78

40 * C funkce / 5 C - Funkce (function) pokrač: #include <stdio.h> int faktorial(int n); int vysledek; // Standardni knihovna // Prototyp funkce void main(void) { // Zacatek programu if((vysledek=faktorial(50))==0) printf( Chybne zadani ); // else printf( Faktorial=%d,vysledek); // Faktorial int faktorial(int n) // Definice funkce { if(n < 0)return(0); if(n == 0)return(1); return(n * faktorial(n-1)); // Rekurse AVT - Jazyk C - Stručný přehled 79 * C funkce / 6 C - Funkce (function) pokrač: void secti(int a[], int n); // Prototyp funkce void main(void) { // Zacatek programu int a[]={1,2,3,4,5,6,7,8; long suma; suma=secti(a,n);.... // Secti n prvku a[] void secti(int a[], int n) // Definice funkce { int i; long suma=0; for(i=0;i<n;i++) suma += a[i]; return(suma); AVT - Jazyk C - Stručný přehled 80

41 C funkce / 7 C - Funkce (function) pokrač: void vymen(int *px, int *py); // Prototyp funkce void main(void) { // Zacatek programu int a=10,b=20; vymen(&a,&b);.... // Zamena x a y void vymen(int *px, int *py) // Definice funkce { // Nahrada volani odkazem int tmp=*px; *px=*py; *py=tmp; AVT - Jazyk C - Stručný přehled 81 * C funkce / 8 C - Funkce (function) pokrač: #include <stdio.h> int porovnejstring(char *s, char *p); char s[]= Nazdar ; char *g= Ahoj ; // Standardni knihovna // Prototyp fce void main(void) { // Zacatek programu int vysledek; if((vysledek=porovnejstring(s,g))==0) printf( Retezce se rovnaji ); else printf( Retezce jsou ruzne ); // Porovnej retezce int porovnejstring(char *s, char *p) // Definice funkce { // Nahrada volani odkazem int i; for(i=0;s[i]==p[i];i++) if(s[i]== \0 p[i]== \0 ) if(s[i]== \0 && p[i]== \0 )return(0); else return(s[i]-p[i]); AVT - Jazyk C - Stručný přehled 82

42 * C funkce / 9 C - Funkce (function) pokrač: #include <stdio.h> int porovnejstring(char *s, char *p); char s[]= Nazdar ; char *g= Ahoj ; // Standardni knihovna // Prototyp fce void main(void) { // Zacatek programu int vysledek; if((vysledek=porovnejstring(s,g))==0) printf( Retezce se rovnaji ); else printf( Retezce jsou ruzne ); // Porovnej retezce int porovnejstring(char *s, char *p) // Definice funkce { // Nahrada volani odkazem for(i=0; *s == *p; i++) if(*s == \0 *p== \0 ) if(*s == \0 && *p== \0 )return(0); else return(*s - *p); AVT - Jazyk C - Stručný přehled 83 * C funkce / 10 C - Funkce (function) vstupni parametry funkce main(): Funkce main() přebírá parametry z příkazového řádku main() má dva vstupní parametry: argc počet parametrů na příkazovém řádku *argv[] pole ukazatelů na příkazy příkazového řádku int main(int argc, char **argv); int main(int argc, char *argv); // Totez příkazový radek ve tvaru c:\>program1 parametr1 parametr2 argc=3 argv argv[0] argv[1] argv[2] program1 parametr1 parametr2 AVT - Jazyk C - Stručný přehled 84

43 C příkazy preprocesoru C - Preprocesor (Preprocessor): Zdrojový text programu v C je před vlastní překladem předzpracován Předzpracování provede Preprocesor takto: -Odstraní komentáře -Nahradí makra jejich definicí -Vykoná ostatní direktivy preprocesoru Každá direktiva preprocesoru začíná na samostatném řádku znakem # Příliš dlouhou příkazovou řádku je možné rozdělit znakem \ Direktivy preprocesoru umožňují: - Definovat makra a rušit jejich definice - #define, #undef - Testovat zda je makro definováno - defined - Vkládat do zdrojového textu hlavičkové soubory - #include - Řídit podmíněný překlad - -#if,#elif,#else,#endif,#ifdef,#ifndef - Definovat nové příkazy preprocesoru závislé na implementaci - #pragma AVT - Jazyk C - Stručný přehled 85 C standardní knihovny / 1 C Standardní knihovny (ANSI C library Standard Library) : Vlastní jazyk C neobsahuje žádné prostředky pro vstup a výstup dat, složitější matematické operace, práci s řetězci, třídění, blokové přesuny dat v paměti, práci s datem a časem, komunikaci s operačním systémem,správu paměti pro dynamické přidělování, vyhodnocení běhových chyb (run-time errors) apod. Tyto a další funkce jsou však obsaženy ve standardních knihovnách (ANSI C Library) dodávaných s překladači jazyka C. Uživatel dostává k dispozici přeložený kód knihoven (který se připojuje linkuje k uživatelovu kódu) a hlavičkové soubory (headers) s prototypy funkcí, novými typy, makry a konstantami Hlavičkové soubory (obdoba interface v Javě) se připojují k uživatelovu kódu direktivou preprocesoru #include < >. Je zvykem, že hlavičkové soubory mají rozšíření *,h, např. stdio.h AVT - Jazyk C - Stručný přehled 86

44 * C standardní knihovny / 2 C Standardní knihovny (ANSI C library Standard Library) pokrač: Standardní knihovny jsou rozděleny do následujících částí: (uvedeno pro ANSI C95): Vstup a výstup (formátovaný i neformátovaný) stdin.h Rozsahy čísel jednotlivých typů limits.h Matematické funkce stdlib.h math.h Zpracování běhových chyb (run-time errors) errno.h assert.h AVT - Jazyk C - Stručný přehled 87 * C standardní knihovny / 3 C Standardní knihovny (ANSI C library Standard Library) pokrač: Standardní knihovny jsou rozděleny do následujících částí: (uvedeno pro ANSI C95) pokrač: Klasifikace znaků (typ char) ctype.h Práce s řetězci (string handling) string.h Internacionalizace (adaptace pro různé jazykové mutace) locale.h Vyhledávání a třídění stdlib.h Blokové přenosy dat v paměti string.h AVT - Jazyk C - Stručný přehled 88

45 * C standardní knihovny / 4 C Standardní knihovny (ANSI C library Standard Library) pokrač: Standardní knihovny jsou rozděleny do následujících částí: (uvedeno pro ANSI C95) pokrač: Správa paměti (Dynamic Memory Management) stdlib.h Datum a čas time.h Komunikace s operačním systémem stdlib.h signal.h Nelokální skok (lokální je součástí jazyka, viz goto) setjump.h AVT - Jazyk C - Stručný přehled 89 Jazyk C stručný přehled konec AVT - Jazyk C - Stručný přehled 90