PRG. verze 1 (1, 2, 3, 5, 6 7, 9 10, 11, 12, 13, 16, 17, 18, 19, 21, 23, 24, 25)

Transkript

1 PRG verze 1 (1, 2, 3, 5, 6 7, 9 10, 11, 12, 13, 16, 17, 18, 19, 21, 23, 24, 25)

2 Seznam otázek: 1. Algoritmus (definice, vlastnosti, postup při řešení problému, grafické znázornění ). 2. Sekvence příkazů a alternativa ( zápisy ve strukturogramu, vývojovém diagramu, jazyku Pascal a C, druhy alternativy ). 3. Cykly - iterace (zápisy ve strukturogramu, vývojovém diagramu, jazyku Pascal a C, druhy iterace). 4. Hlavní rysy programovacích jazyků Pascal a C, jejich historie a vývoj. Způsob zpracování programu. 5. Datové typy v jazyce Pascal. Přehled a charakteristika jejich vlastností. 6. Datové typy a paměťové třídy jazyka C. 7. Zdrojové a hlavičkové soubory v programovacím jazyce C. 8. Structury, uniony, výčtové typy v programovacím jazyce C srovnání s jazykem Pascal(variantní záznam, pole záznamů). 9. Operátory v programovacích jazycích Pascal a C. Pojem priority operátorů. Rozdíly mezi jednotlivými programovacími jazyky. 10. Podprogramy v jazyce Pascal ( procedury, funkce,parametry, rekurzivní procedury a funkce). Jak se tvoří a jaké mají vlastnosti. 11. Funkce v jazyce C. Jak se tvoří a jaké mají vlastnosti. Porovnání s podprogramy v jazyce Pascal. 12. Činnost preprocesoru jazyka C (makra, podmíněný a oddělený překlad). 13. Projekty v programovacím jazyce C. Práce s více moduly. Spojování a překlad programů. Tvorba vlastních projektů. 14. Pointry v jazyce C (pointerová aritmetika, dynamické přidělování paměti). Porovnání práce s pointery v programovacím jazyce Pascal. 15. Jednorozměrné a vícerozměrné pole v jazyce Pascal 16. Jednorozměrné pole v jazyce C (statické a dynamické pole). 17. Vícerozměrné pole v programovacím jazyce C (pole pointerů, pointer na pole, pointer na pointer). 18. Znakové a řetězcové datové typy v jazyce C. Porovnání s jazykem Pascal. 19. Soubory v jazyce C a Pascal (typy souborů, práce se soubory pomocí struktury file, testování otevření a uzavření souboru). 20. Dynamické datové struktury ( spojový seznam, LIFO, FIFO, binární strom). 21. Třídění (druhy a principy). 22. Zdrojové soubory v programovacím jazyce Pascal. Vytváření a funkce unit. 23. Základy OOP (objekt a třída, zapouzdření, dědičnost, polymorfismus). 24. Jazyk Delphi. Tvorba tříd a objektů. Typy souborů v aplikaci v Delphi. 25. Prostředí jazyka Delphi (komponenty, změna vlastnosti komponent).

3 1. Algoritmus Algoritmus jednoznačně určený postup řešení určitého problému je obecnější než zvolený programovací jazyk Vlastnosti algoritmu: konečnost každý krok algoritmu se provede konečný počet krát elementárnost algoritmus se skládá z konečného počtu kroků determinovanost v každé fázi zpracování musí být určen další postup rezultativnost od libovolných vstupních hodnot musíme dospět k požadovaným výsledkům hromadnost algoritmus musí být použitelný pro všechny úlohy stejného typu Vyjádření algoritmu: slovně graficky (vývojové diagramy, strukturogramy) je obecná, nezávislá na programovacím jazyku pomocí programovacího jazyku 3 základní struktury programu: sekvence sled příkazů, které následují za sebou alternativa (větvení) viz. otázka 2 iterace (cykly) viz. otázka 3 Postup při tvorbě programu: analýza problému stanovení podmínek, za kterých má program fungovat (druh počítače, vstupní data, ) sestavení algoritmu sestavení programu testování (odladění) programu Značky vývojového diagramu: Značka Koncová značka Start Příklad Konec Značka přiřazení P=P+1 y=sin(60) Vstup nebo výstup dat Načti A Tiskni A Značka rozhodování A>0 - + Značka podprogramu Záměna Spojka 1

4 2. Sekvence příkazů a alternativa Alternativa úplná, neúplná, vícenásobná, vnořená Sekvence sled příkazů, které následují za sebou Úplná alternativa (větvení) Pascal: if podmínka then příkaz_1 else příkaz_2; - podmínka + C: if (podmínka) příkaz_1; else příkaz_2; příkaz příkaz Neúplná alternativa (větvení) Pascal: if podmínka then příkaz_1; C: if (podmínka) příkaz_1; podmínka + příkaz - Vícenásobná alternativa (větvení) Pascal: case selektor of hodnota_1: příkaz_1; 1, 3..10: příkaz_2; hodnota_2: else příkaz_3; end; příkaz_1; příkaz_2; end; selektor hodnota 1 hodnota 2 hodnota 3 příkaz příkaz příkaz C: switch (selector) case hodnota_1: příkaz_1; break; case hodnota_2: příkaz_1; příkaz_2; break; default: příkaz_3; break; //na posledním řádku nemusí být Selektor musí být ordinálního datového typu. Pascal: je možné použít výčet několika hodnot nebo interval C: není možné použít výčet hodnot nebo interval

5 3. Cykly (iterace) Cyklus s podmínkou na konci vždy se provede alespoň jednou Pascal: C: příkaz příkaz podmínka + repeat příkaz_1; příkaz_2; until bolean_výraz; - Cyklus s podmínkou na konci nemusí se provést ani jednou podmínka + příkaz příkaz Cyklus s parametrem počet opakování je znám předem - příkaz příkaz podmínka - do příkaz_1; příkaz_2; while(bolean_výraz); Pascal: while bolean_výraz do příkaz_1; příkaz_2; end; C: while (bolean_výraz) příkaz_1; příkaz_2; Pascal: stop:=5; for řídící_proměnná:=1 to //*downto*// stop do příkaz_1; příkaz_2; end; C: for (výraz_start; výraz_stop; výraz_iterace) příkaz_1; příkaz_2; + podmínka - Skoky v cyklech break ukončuje nejvnitřnější neuzavřenou smyčku opouští cyklus nebo ukončuje příkaz switch syntaxe (C i Pascal): break; continue skáče na konec nejvnitřnější neuzavřené smyčky a tím vynutí další opakování smyčky neopouští smyčku syntaxe (C i Pascal): continue; goto používá se pro výskok z vnořených cyklů nedá se skočit z jedné funkce do druhé syntaxe (Pascal goto): procedure XY; var deklarace proměnných label error; for i:=0 to 10 do for j:=0 to 10 do if (x[j]=0) then goto error; a[i]=a[i]/x[j]; end; exit; // musí být error: writeln( Dělení nulou ); end; syntaxe (C goto): void XY(void) for (i=0; i<10; i++) for (j=0; j<10; j++) if (x[j]==0) goto err; a[i]=a[i]/x[j]; err: printf( Dělení nulou ); + příkaz příkaz

6 Jednoduché datové typy 5. Datové typy v jazyce Pascal Ordinální: typy celých čísel (byte, word, shorting, integer, longint) typ char typ výčet typ interval Neordinální: typy reálných čísel Operace s ordinálními datovými typy: Operace Funkce Příklad určení předchůdce pred(x) pred(10)=9 určení následníka succ(x) succ(10)=11 určení ordinální hodnoty ord(x) ord( A )=65 zvýšení hodnoty inc(x, y) inc(x, 2) zvýší hodnotu x o 2 snížení hodnoty dec(x, y) dec(x) sníží hodnotu x o 1 Typy celých čísel: Typ Rozsah Velikost byte B word B shorting B integer B longint B Typ char proměnná typu char je určena k práci se znaky obsahuje vždy pouze 1 znak ord( A ) zjištění ordinální hodnoty znaku chr(65) určení znaku chr(65)=#65 Typ výčet umožňuje nám definovat své vlastní hodnoty jednotlivým hodnotám jsou přiřazeny číselné hodnoty tak, že první má hodnotu 0 použité hodnoty jsou v programu chápany jako konstanty type dny=(pondeli, utery, streda, ctvrtek, patek, sobota, nedele); var x:dny; i:integer; a:=succ(pondeli); //a=utery i:=ord(utery); //i=1 end. Operace s celými čísly: Operace Funkce sčítání + odečítání násobení * celočíselné dělení div zbytek po dělení mod absolutní hodnota abs(x) druhá mocnina sqr(x) určení lichosti odd(x) Typ logických hodnot (bolean) nabývá hodnot true a false platí true < false ord(true)=1 ord(false)=0 Typ interval typ interval lze definovat pouze z již definovaného ordinálního typu proměnným tohoto typu můžou být přiřazeny pouze hodnoty spadající do definovaného intervalu type znaky= A.. Z ; cislice= ;

7 Typy reálných čísel: při použití datového typu single, double, extended nebo comp je nutno zapnout podporu koprocesoru nebo jeho emulaci Typ Rozsah Velikost real 2.9* * B single 1.5* * B double 5.0* * B extended 3.4* * B comp B Operace s reálnými čísly: Operace Funkce sčítání + odečítání - násobení * dělení / absolutní hodnota abs(x) druhá mocnina sqr(x) druhá odmocnina sqrt(x) sinus sin(x) cosinus cos(x) arcustangens arctan(x) přirozený logaritmus ln(x) exponenciální funkce exp(x) odseknutí trunc(x) zaokrouhlení round(x) desetinná část frac(x) celá část int(x) Strukturované datové typy Typ pole array viz. otázka 15 Typ řetězec string viz. otázka 18 Typ množina viz. otázka Typ záznam record viz. otázka 8 Typ ukazatel pointer viz. otázka 14 Typ soubor viz. otázka 19 Typ objekt viz. otázka 23

8 6. Datové typy a paměťové třídy jazyka C Globální proměnné definují se mimo funkce (tz. i mimo funkci main) automaticky se nulují paměť se alokuje na začátku programu a uvolňuje na konci Lokální proměnné definují se uvnitř bloku nebo funkce nenulují se automaticky paměť se alokuje a uvolňuje v průběhu programu Datové typy: standardní datové typy uživatelské datové typy Jednoduché datové typy Datový typ char velikost je 1B (8b) není přímo nastavený na signed nebo unsigned, záleží na překladači zda bude signed char (- 128, 127) nebo unsigned char (0, 255) Reálné datové typy liší se v rozsahu, ale i v přesnosti Datový typ Velikost float 32b double 64b long double 80b Celočíselné datové typy v jazyce C existuje několik celočíselných typ lišících se rozsahem hodnot, které lze v nich uchovat rozlišujeme neznaménkové (unsigned) a znaménkové (signed) výchozí nastavení je signed rozsah obecně: <-2 n-1, 2 n 1>, n...velikost v bitech Datový typ Velikost Rozsah short 16b int závisí na OS (typicky 16b) long 32b Datový typ void nemá definovaný rozsah používáme jako návratovou hodnotu funkce, typ formálních parametrů nebo typ ukazatele Strukturované datové typy Struktura viz. otázka 8 Pole viz. otázka 16 a 17 Union viz. otázka 8 Pointer viz. otázka 19 Soubor viz. otázka 19

9 Konstanty viz. otázka 12 (symbolická konstanta makro bez parametru) klíčové slovo: const desítkové: 8, 5, 2, 256 oktálové (osmičkové): 012, 07, 03, začínají 0 hexadecimální: 0xA6, 0XA6, 0xFF, může být jak malé, tak velké x reálné:.13, 0.13, 13.5 řetězcová: řetězcová konstanta znaková: Z, + typ konstanty je dán velikostí: 3658L (long), 3658LU (unsigned long), 13.5F (float), 13.5L (long double) zápis: const vek=20, const text= ahoj Paměťové třídy určí, ve kterých částech paměti bude proměnná kompilátorem umístěna a kde bude viditelná (dostupná) rozšiřují použití lokálních a globálních proměnných 4 typy: auto, extern, static, register static int a, b; // některé překladače nastaví pouze proměnnou a jako static Paměťová třída auto je přímo nastavena pro lokální proměnné Paměťová třída register proměnná bude uložena registru procesoru, pokud je volný, jinak bude zapsána do paměti neváže se na konkrétní registr pouze pro lokální proměnné používá se pro proměnné cyklu, nebo pro často volané formální parametry adresu této proměnné nemůžeme získat Paměťová třída extern je přímo nastavena pro globální proměnné sdílená proměnná int a; A.C Projekt B.C extern int a; void fce(int x) a=a+x; Paměťová třída static Lokální proměnné paměť se alokuje v datové oblasti, mezi dvěmi volání funkce si uchovává svou hodnotu při prvním spuštění se vynuluje při každém volání funkce FCE se hodnota q zvýší o 1 void FCE(void); FCE(); void FCE(void) static int q; q++; Globální proměnné je použitelná pouze v souboru, ve kterém ji definujeme A.C static int a; a++; Projekt B.C static int a; void fce(int x) a=a+x; 2 různé proměnné

10 7. Zdrojové a hlavičkové soubory v programovacím jazyce C Zdrojové soubory mají příponu *.c, obsahují zdrojový kód programu, funkcí apod. obsahují: dokumentační část jméno souboru, verze, stručný popis, jméno autora, datum, vkládání hlavičkových souborů definice symbolických konstant a maker s parametry použitých pouze v tomto modulu definice lokálních typů (pomocí typedef) Hlavičkové soubory mají příponu *.h, obsahují deklarace funkcí (hlavičky) obsahují: definice symbolických konstant a maker s parametry definice globálních datových typů (pomocí typedef) deklarace funkcí nesmí obsahovat žádné definice funkcí nebo inicializace sdílených proměnných Komentáře //toto je řádkový komentář /* toto je komentář toto je komentář toto je komentář */ Připojení hlavičkových souborů #include <název souboru.h> hledá pouze v cestě nastavené v MENU OPTIONS DIRECTORIES Include files #include název souboru.h prohledává nejdříve aktuální adresář a pak v nastavené cestě systémové hlavičkové soubory naše vlastní hlavičkové soubory Identifikátory prom, PROM, Prom 3 různé proměnné _prom, prom_ nedoporučuje se označovat proměnné takto prom_i toto označování je povolené klíčová slova (if, while, do...) se píší malými písmeny délka identifikátoru není omezené, ale u ANSI C je omezena na 31 znaků Globální proměnné definují se mimo funkce (tz. i mimo funkci main) automaticky se nulují paměť se alokuje na začátku programu a uvolňuje na konci Lokální proměnné definují se uvnitř bloku nebo funkce nenulují se automaticky paměť se alokuje a uvolňuje v průběhu programu Stavba programu #include <stdio.h> int Secti(int x, int y); // deklarace funkce // pokud uvedeme void main(), tak compiler si defaultně dosadí do prázdné // závorky typ int int soucet=0; soucet=secti(2, 3);

11 int Secti(int x, int y) return x+y; // definice funkce Speciální znaky: \ změna běžného významu \n přechod na nový řádek \f nová stránka \t tabulátor \\ \ (zpětné lomítko) \ (uvozovka) \0 nulový znak %% % (procento) Formáty výstupu: %c znak %d desítkové číslo typu signed int %ld desítkové číslo typu signed long %u desítkové číslo typu unsigned int %lu desítkové číslo typu unsigned long %f float %Lf long double %lf double %x hexadecimální číslo zapsané malými písmeny %X hexadecimální číslo zapsané velkými písmeny %o oktálové číslo %s řetězec (pole znaků) %p adresa

12 9. Operátory Operátor určuje operaci, která se má s operandem nebo operandy provést mohou být unární (1 operand) nebo binární (2 operandy) Unární operátory mají zpravidla vyšší prioritu než binární operátory unární operátory využívají zpravidla prefixový zápis (nejprve operátor, pak operand) vyjímkou jsou operátory ++ a --, které mají různý význam v prefixovém a postfixovém zápisu Unární operátory: + unární plus +5 - unární mínus inkrementace a++ -- dekrementace a--! logická negace (C, C++)!a ~ binární negace (C, C++) ~a & operátor reference (C, C++) &a * operátor dereference (C, C++) *a not logická negace (Pascal) not a not binární negace (Pascal) not operátor reference ^ operátor dereference (Pascal) a^ Prefixový zápis: +5, &a, *a, ++a, --a Postfixový zápis: a++, a--, a^ Operátor a operand b + c operandy operátor Operátor inkrementace a dekrementace při použití v prefixovém zápisu se nejdříve provede inkrementace (dekrementace) a pak se použije proměnná ve výrazu při použití v postfixovém zápisu se nejdříve použije proměnná ve výrazu a pak se provede inkrementace (dekrementace) int a=10, b=0; b=a++; // b=10, a=11 b=++a; // b=22, b=12 Binární operátory mají 2 operandy, operátor se píše mezi ně aritmetické, bitové, logické, přiřazovací, relační, přístupové, oddělovací operátory, operátory posuvu, ternární operátor Aritmetické operátory: + sčítání - odečítání * násobení / dělení % zbytek po celočíselném dělení (C, C++) mod div / zbytek po celočíselném dělení (Pascal) celočíselné dělení (Pascal) celočíselné dělení (C, C++), vše musí být celočíselného datového typu Relační operátory: == test rovnosti (C, C++) = test rovnosti (Pascal)!= nerovnost (C, C++) <> nerovnost (Pascal) > větší < menší >= větší nebo rovno <= menší nebo rovno

13 Operátor posuvu: << bitový posun doleva, posun všech bitů o 1 pozici doleva >> bitový posun doprava, posun všech bitů o 1 pozici doprava Logické operátory: logický součet (C, C++) && logický součin (C, C++) or logický součet (Pascal) and logický součin (Pascal) xor exkluzivní součet (Pascal, v C není) Pravdivostní tabulka: A B A && B A B A xor B Bitové operátory: logický součet (C, C++) & ^ or and xor logický součin (C, C++) exkluzivní součet (C, C++) logický součet (Pascal) logický součin (Pascal) exkluzivní součet (Pascal) Oddělovací operátor (, ) (pouze C, C++): for (i=0; i<10; i++, j--) Logické x bitové operátory logické operátory pracují s proměnnou, jako by to byla jedna logická proměnná bitový operátor pracuje s každým bitem operandu jako s logickou proměnnou Přístupové operátory (. ) (->): slouží k přístupu k položkám struktury nebo unionu 1. operandem je struktura, 2. operandem je název položky Ternární operátor (podmíněný výraz) (pouze C, C++): výraz = podmínka? hodnota_true : hodnota_false; int i=(3==3)?1:2; // i=1 Priorita operátorů: 1. volání funkce, index pole, přístupové operátory 2. unární operátory 3. aritmetické operátory 4. posuvné operátory 5. relační operátory 6. bitové operátory 7. logické operátory 8. ternární operátor 9. přiřazovací operátor 10. oddělovací operátor Přiřazovací operátory (C, C++): = a=b += a = a + b -= a = a - b *= a = a * b /= a = a / b %= a = a % b &= a = a & b = a = a b ^= a = a ^ b Výraz x přiřazení výraz je tvořen posloupností operandů a operátorů, které určují jak se má výraz vyčíslit Přiřazovací operátor (Pascal): a:=10; a:=a+10; a = b + c operandy operátor výraz přiřazení Argumenty logických výrazů se vyhodnocují zleva doprava. if ((y!=0) && (x/y<z)) y 0 nevyhodnocuje se další podmínka

14 10. Podprogramy v jazyce Pascal Podprogramy dovolují vícenásobné použití již napsaného kódu rozčleňují program do přehledných částí, umožňují nám definovat nové příkazy jazyka každá deklarace podprogramu obsahuje hlavičku funkce nebo procedury, deklarace lokálních objektů (návěští, typů, proměnných, funkcí a procedur) a tělo podprogramu v hlavičce podprogramu je uveden název podprogramu, seznam formálních parametrů a u deklarace funkce typ návratové hodnoty v deklarací funkcí a procedur se používají formální parametry (při volání funkce jsou nahrazeny skutečnými parametry) 2 typy podprogramů (procedura, funkce) Procedura hlavička procedury: procedure ID(formální parametry); Funkce vrací hodnotu hlavička funkce: function ID(formální parametry):návratový typ Parametry volané hodnotou jsou používány v případě, že chceme předat podprogramu nějakou hodnotu, ale změna této hodnoty uvnitř podprogramu nebude mít vliv na skutečný parametr podprogram nepracuje se skutečnými parametry, ale s jejich kopiemi Parametry volané odkazem podprogram pracuje přímo se skutečným parametrem, tz. změna hodnoty parametru v podprogramu bude mít za následek změnu skutečného parametru parametrům volaným odkazem předchází v seznamu formálních parametrů klíčové slovo var Rekurzivní podprogramy rekurze = podprogram volá sám sebe, 2 typy Přímá rekurze podprogram volá sám sebe procedure rekur_1( ); function rekur_2( ); procedure rekur_1( ); rekur_1( ); end; function rekur_2( ); F:=F*rekur_2( ); end; Vzájemná rekurze nastane tehdy, zavolá-li jeden podprogram jiný podprogram obecným pravidlem Pascalu je, že každý identifikátor může být použít poté co byl deklarován z tohoto důvodu zavádí Pascal tzv. předsunutou deklaraci pomocí direktivy forward, která následuje za hlavičkou procedury nebo funkce (direktiva = speciální instrukce pro překladač) direktiva forward říká, že tělo podprogramu bude uvedeno později procedure B( ); forward; procedure A( ); B( ); end; procedure B; parametry.. end; // nyní se již neuvádí formální

15 Příklad: procedure Ahoj; // deklarace procedure Zamena(var a, b:integer); function Math_Pi:real; // formální parametry procedure Ahoj; // definice writeln( Ahoj ); end; procedure Text(a:String); writeln(a); end; // deklarace a definice v jednom procedure Zamena(var a, b:integer); var p:integer; p:=a; a:=b; b:=p; end; function Math_Pi:real; Math_Pi:=3.14 end; var x, y:integer; Ahoj; Text( nejaky text nebo promenna ); x:=5;y:=10; Zamena(x, y); // x, y jsou skutečné parametry end.

16 11. Funkce v jazyce C Funkce funkce je základním stavebním prvkem jazyka C program musí obsahovat jednu funkci, která se jmenuje main zpracování programu začíná funkcí main a končí opuštěním této funkce jedna funkce nemůže obsahovat ve svém těle definici jiné funkce všechny funkce vrací hodnotu, ale dají se použít i jako procedury (v případě, že jako návratový typ uvedeme void (zde pak nepoužijeme return)) Deklarace funkce hlavička funkce obvykle se uvádí před funkcí main nevymezuje se paměť Definice funkce tělo funkce obvykle se uvádí za funkcí main vymezuje paměť funkce vrací jakýkoliv datový typ, i strukturovaný Deklarace, definice a volání funkce: int max(int a, int b); //deklarace funkce, nelze použít int a, b int x; x=max(5, 9); //volání funkce; 5, 9 jsou skutečné parametry int max(int a, int b) //definice funkce; a, b jsou formální parametry return (a>b)?a:b; Parametry volané hodnotou jakákoliv změna formálních parametrů uvnitř funkce je pouze dočasná skutečné parametry nemohou být ve funkci změněny pracuje se s kopiemi skutečným parametrů Rekurzivní funkce je to funkce, která volá sama sebe velké nároky na zásobník long Faktorial(int x); long Faktorial(int x) return (x<=1)?1:faktorial(x-1)*x; Parametry volané odkazem jakákoliv změna formálních parametrů uvnitř funkce způsobí i změnu skutečných parametrů využití ukazatelů v těle funkce pracujeme s adresou proměnné Funkce bez parametrů int Secti(); int x=secti(); int Secti() int a, b; scanf( %d%d, &a, &b); return (a+b);

17 Ukazatel na funkci int Secti(int a, int b); int Odecti(int a, int b); int c; int (*operace)(int, int); operace=&secti; c=secti(5, 5); operace=&odecti; c=odecti(10, 5); int Secti(int a, int b) return a+b; int Odecti(int a, int b) return a-b;

18 Preprocesor zpracovává řádky označené # odstraňuje komentáře rozvíjí makra vkládá hlavičkové soubory provádí podmíněný překlad 12. Činnost preprocesoru jazyka C Makra bez parametrů (symbolická konstanta) píší se velkými písmeny preprocesor nahradí symbolickou konstantu za skutečnou hodnotu pokud je délka konstanty delší než řádka, musí být na konci řádky znak \ definice makra bez parametru: #define NÁZEV_MAKRA HODNOTA_MAKRA zrušení makra: #undef NÁZEV MAKRA Makra s parametry (vkládané funkce) píší se malými písmeny preprocesor nahradí vkládanou funkci hodnotou makra před překladem jsou preprocesorem nahrazena konkrétním textem definice makra s parametrem: #define NÁZEV_MAKRA(argument_1, argument_2) HODNOTA_MAKRA volání: NÁZEV MAKRA(parametr 1, parametr 2); Makra bez parametrů příklad: #define MAXIMUM #define PI 3.14 #define AND && #define POZDRAV AHOJ #define DLOUHA Toto je velmi dlouhá konstanta\ a proto musí být rozdělena #define ERROR printf( Nulou nelze dělit ); #define POCET 10 #undef POCET printf( %s, POZDRAV); if (a==0) ERROR; Makra s parametry příklad: #define sqr(x) ((x)*(x)) //x musí být v () jinak sqr(a+b)=a+b*a+b #define abs(a) ((a)<0? \ //pro pokračování na dalším řádku se píše \ (a)*(-1):a) #define max(a) int c=10; if (a>c) printf( a>10 ); vysledek=sqr(4); max(20); //středník nemusí být, protože blok je ukončen v definici makra

19 Podmíněný překlad umožňuje nám vytvořit ladící části (pomocné výpisy, funkce), které jsou trvalou součástí zdrojového souboru, ale volitelnou součásti programu Řízení překladu hodnotou konstantního výrazu záleží na hodnotě symbolické konstanty #if KONSTANTÍ_VÝRAZ příkaz_1; příkaz_2; #endif #if KONSTANTNÍ_VÝRAZ příkaz_1; příkaz_2; #else příkaz_3; příkaz_4; #endif #define PC_AT 1 #if PC_AT #include<conio.h>//splní se pro všechny hodnoty různé od 0 #else #include<stdio.h> #endif Řízení překladu definicí makra záleží, zda je makro definováno nebo ne #define PC_AT #ifdef PC_AT #include<conio.h> #else #include<stdio.h> #endif operátor defined používá se tehdy, chceme-li při podmíněném překladu vytvářet logické výrazy #if defined (PC_AT) && defined (PC_ATX) definice maker můžeme zapisovat Options Compiler Code Generation Defines oddělují se středníkem, poslední ne Vkládání souborů do jednoho souboru je vloženo několik dalších zdrojových souborů při změně 1 souboru se musí zkompilovat i všechny ostatní A.C B.C C.C X.C #include A.C #include B.C #include C.C X.OBJ Oddělený překlad při změně 1 souboru se zkompiluje pouze ten změněný využití v projektech A.C B.C C.C A.OBJ B.OBJ C.OBJ

20 13. Projekty v programovacím jazyce C Projekt používá se v případě, že je program složený z více zdrojových souborů (modulů) překládaných odděleně dohromady se pak sestaví pomocí linkeru výhody dělení: přehlednost není třeba kompilovat celý program, ale pouze konkrétní soubor spolupráce více autorů Vytvoření nového projektu Menu Project Open project Notes projektu Menu Window Project notes uložení stejně jako klasický soubor Vložení souborů do projektu Menu Project Add item nebo klávesa <INSERT> vkládají se pouze.c soubory, hlavičkové soubory (.h) se nevkládají Přeložení souborů (do *.obj) přeložení aktuálně otevřeného souboru: Menu Compile Compile přeložení všech souborů v projektu: Menu Compile Make soubory jsou přeloženy do relativního (objektového) kódu (proměnné a funkce mají relativní adresy) Slinkování souborů s příponou *.obj do jednoho *.exe souboru Menu Compile Link Spuštění programu Menu Run Run Uzavření projektu před uzavřením projektu je nutno jej uložit Menu Options Save V projektech se využívá podmíněný překlad a oddělený překlad (viz. otázka 12). Ve složitějších projektech je vhodné překládat hlavičkové soubory podmíněně. Hlavičkový soubor se může používat ve více souborech, a tím pádem by se vložil několikrát. #ifndef _muj_h #define _muj_h int Maximum(int a, int b, int c); int Minimum(int a, int b, int c); #endif

21 16. Jednorozměrné pole v jazyce C Pole je strukturovaný datový typ uspořádaná množina hodnot stejného datového typu v paměti zabírá souvislý blok indexy pole začínají od 0 jméno pole je jeho adresou (adresa prvního prvku, pole = &pole[0]) Statické pole Deklarace pole #define N 10 int a[n]; // vytvoření 10-prvkového pole a a[0]=9; a[6]=-6; a[10]=100; // compiler to přeloží, ale protože neexistuje prvek s indexem 10 bude tato hodnota uložena v paměti až za polem, a ztratíme ji a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] Plnění pole int a[10]; int i; for (i=0; i<10; i++) a[i]=random(50); Vypsání pole int a[10]; int i; for (i=0; i<10; i++) printf( %d\n, a[i]); Kopírování pole Třídění pole, viz. otázka 21 int a[10]; int i, j; Naplnění pole při jeho vytvoření int a[5]= ; for (i=0; i<10; i++) for (j=0; j<9; j++) if (a[j]>a[j+1]) int pom=a[j]; a[j]=a[j+1]; a[j+1]=pom; Porovnání pole x=y; // nelze; x, y jsou konstantní adresy pole x==y; // nelze for (i=0; i<10; i++) x[i]=y[i]; for (i=0; i<10; i++) if (x[i]==y[i]) break;

22 Pole a pointery &pole[i]==bázová adresa pole + i*sizeof(typ); int *p; int pole_1[10], pole_2[10]; p=pole_1; pole_1=p; // nelze, adresa pole_1 je konstanta, je neměnná pole_2=pole_1; // nelze, pole_1 pole_2 p pole_1[i]=*(p+i); // i...index pole, neposunujeme se po B, ale po indexech Shodné zápisy: pole_1[i]=10; *(p+1)=10; p[1]=10; *(pole_1+1)=10; Shodné zápisy: *p=2; *(p+0)=2; *(pole_1+0)=2; p[0]=2; pole_1[0]=2; Dynamické pole Vytvoření dynamického pole int *p; p=(int*)malloc(sizeof(typ)*10); // vytvoření 10-prvkového pole p[0]==*p; p[1]==*(p+1); p Jednorozměrné pole jako parametr funkce Deklarace: int Maximum(int pole[], int pocet); // nebo: int Maximum(int *pole, int pocet); Volání: x=maximum(pole_1, 10); Definice nového datového typu #define N 10 typedef int TPole[N]; TPole a; // int a[10];

23 17. Vícerozměrné pole v programovacím jazyce C Pravoúhlé pole každý řádek tohoto pole má stejný počet sloupců pokud není znám počet řádků nebo počet sloupců pole v době překladu není pravoúhlé Vícerozměrné statické pole jazyk C bere dvourozměrné pole jako pole o N prvcích, kde každý prvek je pole o M prvcích v době překladu musí být znám počet řádků a sloupců int p[2][3]; // 2 řádky, 3 sloupce p==p[0]==&p[0][0]; p[0][[3]=5; // lze, uloží se do p[1][0] p p[0][0] p[0] 5 p[1][0] p[1] Dynamické pole Pole pointerů (dynamické pole) v době překladu musí být znám počet řádků p[0] p[1] int *p[2]; // 2 řádky p p[0]=(int*)malloc(sizeof(int)*3); p[1]=(int*)malloc(sizeof(int)*3); p[0][3]=5; // nelze p[1][0] free(p[0]); free(p[1]); p[0][1] 5 Pointer na pole (dynamické pole) v době překladu musí být znám počet sloupců int (*p)[3]; // 3 sloupce p p=(int(*)[])malloc(sizeof(int)*2*3); p[0] p[1] p[0][3]=5; free(p); // lze p[0][0] 5 p[1][0] Pointer na pointer (dynamické pole) v době překladu neznáme počet sloupců, ani počet řádků int **p; p[0] p[1] p=(int**)malloc(sizeof(int*)*2); p p[0]=(int*)malloc(sizeof(int)*3); p[1]=(int*)malloc(sizeof(int)*3); p[0][3]=5; // nelze p[1][0] free(p[0]); free(p[1]); free(p); p[0][1] 5

24 Dvojrozměrné pole jako parametr funkce int Maximum(int p[][3]); int Maximum(int (*p)[2]); // name počet řádků pole // známe počet sloupců pole int Maximum(int **p); // neznáme počet řádků, ani sloupců pole

25 18. Znakové a řetězcové datové typy Jazyk C znak char Datový typ char velikost je 1B (8b) není přímo nastavený na signed nebo unsigned obsahuje kód znaku podle ASCII tabulky v rozmezí 0 až 255 Práce se znakem: char zn= x ; zn=32; zn= ; zn=getch(); // mezera // mezera // načtení 1 znaku // načtení jednoho znaku, čeká na stisk <enter> scanf( %s, &zn); Jazyk Pascal znak char Datový typ char velikost je 1B (8b) uchovává pouze 1 znak obsahuje kód znaku podle ASCII tabulky v rozmezí 0 až 255 apostrof ( ) se vyjadřuje jako dvojice apostrofů var zn:char; zn:= ; end. Práce se znakem: var zn:char; zn:= A ; // zn:=#65; zn:=upcase( x ); // zn=x zn:=readkey; // načtení 1 znaku // načtení jednoho znaku, čeká na stisk <enter> ReadLn(zn); WriteLn(Chr(65)); // vypíše A WriteLn(Ord( A )); // vypíše 65 end. Jazyk C řetězec Řetězcové konstanty konstantní ukazatel do paměti const text= ahoj ; Řetězec speciální typ pole, kde každý prvek je typu char je ukončen znakovou nulou (\0 první znak v ASCII tabulce) délka řetězce je omezena velikostí paměti Statický řetězec char s[]= AHOJ ; char s[10]= AHOJ ; // automaticky nastaví délku A H O J \ char s[5]; s= AHOJ ; // nelze, s je konstantní ukazatel

26 Dynamický řetězec char *s; char *s2= AHOJ ; // lze, definice s inicializací s=(char*)malloc(sizeof(char)*5); s= AHOJ ; // nelze, s je konstantní ukazatel Čtení a vypsání řetězce char s[10]; scanf( %s, s); // scanf nečte mezery, DOBRÝ_DEN načte pouze DOBRÝ gets(s); // přečte celý řetězec puts(s); // == printf( %s\n, s); Nulový řetězec x nulový ukazatel char *s; s=(char*)malloc(sizeof(char)*10); s[0]= \0 ; char *p; p=null; Řetězcová x znaková konstanta a a velikost: 2B velikost: 1B obsahuje \0 Funkce pro práci s řetězci jsou v hlavičkovém souboru STRING.H Kopírování řetězce: char s1[5]; char *s2= text // strcpy(cíl, zdroj); strcpy(s1, s2); Zjištění délky řetězce: char *s= text ; int delka; // nepočítá se \0 delka=strlen(s); Převedení na velké znaky: char *strupr(char *s); Převedení na malé znaky: char *strlwr(char *s); Spojení 2 řetezců: char s[20]= Borland ; char s2[3]= C ; strcat(s, s2); Převod řetězců na čísla: int atoi(char *string); long atoil(char *string); double atof(char *string); // s== Borland C ; Porovnání 2 řetězců: char s1[4]= ABC ; char s2[4]= ABD ; int i; i=strcmp(s1, s2); // i<0 Návratové hodnoty: i<0 s1<s2 i=0 s1==s2 i>0 s1>s2

27 Jazyk Pascal řetězec datový typ string Řetězec maximální délka řetězce může být 255 znaků není-li uvedena délka řetězce, předpokládá se délka 255 znaků nultý prvek řetězce obsahuje skutečnou délku řetězce var a:string[30]; // 30 znaků b:string; // 255 znaků a:= text ; // lze ReadLn(a); WriteLn(a); end. Zjištění délky řetězce: Length(s:string):integer Další funkce pro práci s řetězci: Copy vracení podřetězce z řetězce Delete smazání podřetězce z řetězce Insert vložení podřetězce do řetězce Pos vyhledání podřetězce v řetězci Spojení řetězců: var a, b, c, v:string; a:= Borland ; b:= ; c:= C v:=a+b+c end. // v=borland C Spojení řetězců pomocí funkce: je-li výsledek delší než 255 znaků, je zkrácen na tuto délku var a, b, c, v:string; a:= Borland ; b:= ; c:= C v:=concat(a, b, c); end. // v=borland C Převod čísla na řetězec: Str(x [:width [:decimal]], var s:string); width = celkový počet znaků decimal = počet desetinných míst pokud jsou volitelné parametry zadány, ale numerická hodnota ve své znakové reprezentaci zaujme větší počet míst, než je zadáno volitelnými parametry, jsou tyto hodnoty ignorovány Převod řetězce na číslo: Val(s:string; var v; code:integer); v je celočíselného nebo reálného typu při úspěšném dokončení procedury má proměnná code hodnotu 0, při chybě obsahuje index znaku, u kterého došlo k chybě

28 19. Soubory v jazyce C a Pascal Soubor z hardwarového hlediska posloupnost Bajtů uložených na vnějším médiu, (nejčastěji na disku)uložených v blocích (bloky mají stejnou velikost) Soubor z uživatelského hlediska posloupnost po sobě jdoucích Bajtů od začátku do konce souboru OS nám dává tyto Bajty ve správném pořadí Jazyk C Vstupně / výstupní operace jsou bufferovány (buffer vyrovnávací paměť). Vstup: přečte ze souboru celý blok dat a uloží je do bufferu, data se pak již čtou z bufferu Výstup: data se zapisují do bufferu, když je plný, data se uloží na disk Základní operace pro soubory jsou v hlavičkovém souboru stdio.h Režimy při otevírání souborů r w a otevření exitujícího souboru pro čtení vytvoření nového souboru pro zápis otevření souboru pro připisování dat na jeho konec r+ otevření souboru pro čtení a zápis w+ otevření souboru pro zápis a čtení a+ otevření souboru pro čtení a připojení dat na jeho konec rb wb ab otevření exitujícího binárního souboru pro čtení vytvoření nového binárního souboru pro zápis otevření binárního souboru pro připisování dat na jeho konec Při otevření souboru pro čtení (r, r+, rb) musí soubor existovat. Jestliže otevřeme soubor pro zápis (w, w+, wb) a soubor již existuje, bude zkrácen na 0 délku. Jestliže otevřeme soubor pro připojení dat na jeho konec a soubor neexistuje, bude vytvořen. Otevření souboru FILE *fr, *fw; // FILE je struktura popisující soubor fr=fopen( C:\\název_souboru.txt, r ); // fopen vrací ukazatel fw=fopen( název_souboru2.txt, w ); // druhý parametr určuje typ otevření Čtení 1 znaku FILE *fr; char c; // soubor obsahuje abecedu fr=fopen( x.txt, r ); c=getc(fr); c=getc(fr); // c= a // c= b Zápis 1 znaku FILE *fw; char c= x ; fr=fopen( x.txt, w ); putc(c, fr); // zapíše do souboru x

29 Formátované čtení ze souboru FILE *fr; int a, b, c; fr=fopen( x.txt, r ); // přečtení 3 čísel ze souboru fscanf(fr, %d%d%d, &a, &b, &c); fscanf(f, formát, argumenty); Formátovaný zápis do souboru FILE *fw; int a=1, b=2, c=3; fw=fopen( x.txt, w ); // zápis 3 čísel do souboru fprintf(fw, %d%d%d, a, b, c); fprintf(f, formát, argumenty); Ukončení práce se souborem fclose(f); // data se přesunou z bufferu do souboru + uzavření souboru fflush(f); // vyprazdnění bufferu, data se přesunou z bufferu do souboru Testování konce souboru 1. Pomocí symbolické konstanty EOF (End Of File) je definována v stdio.h, standardně má hodnotu 1 while ((c=getc(fr))!=eof) // c musí být typu int, protože EOF=-1 printf( %d, c); 2. Pomocí standardního makra feof(file *f) makro vrací nenulovou hodnotu (true), pokud jsme na konci souboru while ((feof(fr))==0) putch(getc(fr)); Testování konce řádky if ((c=getc(fr))!= \n ) Testování správnosti otevření a uzavření souboru při nesprávném otevření vrací funkce fopen hodnotu NULL při nesprávném uzavření vrací funkce fclose hodnotu EOF Binární x textové soubory Výhody binárních souborů pro uchovávání stejného množství informací vyžadují méně prostoru rychlejší přístup (není potřeba provádět konverzi čísel) Nevýhody binárních souborů nelze je prohlížet běžným editorem (jde, ale nic z toho nepoznáme) Rozdíl binárních a textových souborů int x=2632; binární soubor: zabere 2B (int zabírá 2 B) textový soubor: zabere 4B (4 znaku po 1 B)

30 Soubory v jazyce C a Pascal (typy souborů, práce se soubory, testování otevření a uzavření souboru, rozdíly mezi binárními a textovými soubory).

31 21. Třídění Třídící algoritmy slouží k třídění a řazení dat podle námi zvoleného klíče nedá se říci, který algoritmus je nejlepší, musíme si vybrat podle typu dat, jejich množství a jiných požadavků Vlastnosti třídících algoritmů Přirozenost třídící algoritmus se chová přirozeně, je-li doba seřazení již částečně uspořádané posloupnosti kratší než doba seřazení neuspořádané posloupnosti Operační složitost (rychlost) počet porovnání klíčových položek, která jsou nutná pro získání uspořádané posloupnosti závislost doby řazení na počtu řazených prvků n 2, n*log 2 x Stabilita stabilní třídící algoritmus je takový, který po seřazení zachová pořadí stejných prvků nestabilní algoritmy jsou obvykle rychlejší Dobrý třídící algoritmus musí být: co nejkratší, nejrychlejší stabilní přirozený Metody třídění Vnitřní veškerá data se vejdou do interní paměti počítače rychlost třídění závisí na počtu porovnání a záměn Vnější data se nevejdou do interní paměti počítače a jsou uloženy v souboru na disku rychlost třídění je ovlivněna rychlostí přístupu k vnější paměti Druhy třídících algoritmů bubble sort základní bubble sort upravený (pozná, zda je pole setřízené) bubble sort s boolean shaker sort (oboustranná bublina) select sort (výběr minimálního a maximálního prvku) insert sort (vkládání, zatříďování) binární zatříďování quick sort heap sort

32 Bubble sort Bubble sort I = 1..N-1 J = 1..N-1 A[j]>A[j+1] J++ Výměna(A[j], A[j+1]) // třízená posloupnost // i=1, j= // i=1, j= // i=1, j= // i=2, j= // i=2, j= // i=2, j= // i=3, j= // i=3, j= // i=3, j=3 I++ Konec

33 OOP objektově orientované programování je založeno na komunikaci objektů Objekt je určen množinou dat a množinou přesně stanovených operací, které může používat, tz. má vlastnosti a schopnosti (členské metody funkce) zabírá místo v paměti (něco jako proměnná) 23. Základy OOP Třída abstraktní datový typ nezabírá místo v paměti je definován uživatelem charakterizuje vlastnosti a schopnosti několika podobných objektů podobá ses struktuře v jazyce C, může však obsahovat i funkce, které označujeme jako metody viz. otázka 24 Třída x objekt: rozpocet moje_peníze; // rozpocet třída, moje_peníze - objekt Základní vlastnosti OOP Zapouzdření spojení dat a metod v jeden celek určuje přístup k datům (private, public, protected) k proměnným se přistupuje přes metody (jsou-li deklarovány jako private) fce_4 fce_1 data fce_3 fce_2 Dědičnost možnost odvozovat nové třídy, která dědí data a metody z jedné nebo více tříd potomek využívá základní metody rodičovské třídy Jednoduchá dědičnost potomek má jednoho předka rodičovská třída potomek Vícenásobná dědičnost potomek má více než jednoho předka Opakovaná dědičnost Polymorfismus (vícetvárnost)

34 Deplhi vizuální vývojové prostředí (Visual Basic, Visual C++, C++ Builder) systém pro vývoj aplikací pro Windows s programovacím jazykem objekt Pascal 24. Delphi Typy souborů v Delphi: *.dpr delphi project, uchovává informace o projektu *.pas soubor obsahuje unitu *.dfm definice formuláře (binární soubor) *.res obsahuje např. ikony (binární soubor) *.dll dynamické knihovny *.dpr, *.dfm, *.pas jsou nutné Tvorba třídy a objektu Unit time; Interface Type Cas=class Private Hodina, Minuta, Sekunda:byte; Public Constructor Init(h, m, s:byte); // vytváří objekt, přiděluje paměť a inicializuje data Procedure Zmen_Hodinu(h:byte); Function Dej_Hodinu:byte; End; Implementation Constructor Cas.Init(h, m, s:byte); Begin Hodina:=h; Minuta:=m; Sekunda:=s; End; Procedure Zmen_Hodinu(h:byte); Begin Hodina:=h; End; Function Dej_hodinu:byte; Begin Dej_Hodinu:=Hodina; End; End. ===================================================================== Unit Uziti; Interface Uses Time; Var Ted:Cas; // Ted je objekt Hour:byte; Implementation Begin Ted.Init(22, 22, 22); Ted.Hodina:=24; // chyba, přímý přístup je zakázán, viz. otázka 23 Ted.Zmen_Hodinu(24); Hour:=Ted.Dej_Hodinu; End; End.

35 Integrované prostředí jazyka Delphi obsahuje: 25. Prostředí jazyka Delphi Hlavní okno obsahuje hlavní nabídku (menu), panel s nástroji Návrhář formuláře pracujeme s ním v době návrhu (design mode) na formulář vkládáme komponenty chování a vzhled komponent můžeme měnit v režimu návrhu nebo za běhu programu (runtime mode) Inspektor objektu obsahuje seznam komponent použitých v programu, vlastnosti a události komponenty Editor kódu View Project manager seznam všech unit, formulářů apod. Vlastnosti objektu: aligment horizontální zarovnání layout vertikální zarovnání wordwrap psaní do více řádek hint text tipu showhint zobrazovat tipy cursor jaký kurzor se má zobrazit nad daným prvkem