PRG
verze 1 (1, 2, 3, 5, 6 7, 9 10, 11, 12, 13, 16, 17, 18, 19, 21, 23, 24, 25)
Seznam otázek: 1. 2.
Algoritmus (definice, vlastnosti, postup při řešení problému, grafické znázornění ). 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).
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
Příklad Start
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
-
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;
C: if (podmínka) příkaz_1; else příkaz_2;
podmínka
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: begin příkaz_1; příkaz_2; end; else příkaz_3; end;
selektor
hodnota 1 příkaz
hodnota 2 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
hodnota 3 příkaz
3. Cykly (iterace) Cyklus s podmínkou na konci ׃vždy se provede alespoň jednou Pascal:
C:
příkaz
příkaz
příkaz
příkaz
podmínka
-
+
podmínka -
+
do {
repeat příkaz_1; příkaz_2; until bolean_výraz;
příkaz_1; příkaz_2; }while(bolean_výraz);
Cyklus s podmínkou na konci ׃nemusí se provést ani jednou Pascal: podmínka + příkaz příkaz
-
while bolean_výraz do begin příkaz_1; příkaz_2; end;
C: while (bolean_výraz) { příkaz_1; příkaz_2; }
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; begin for i:=0 to 10 do for j:=0 to 10 do begin if (x[j]=0) then goto error; a[i]=a[i]/x[j]; end; exit;
Cyklus s parametrem ׃počet opakování je znám předem Pascal: stop:=5; for řídící_proměnná:=1 to //*downto*// stop do begin 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 + příkaz příkaz
-
// 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”); }
5. Datové typy v jazyce Pascal Jednoduché datové typy Ordinální: ׃typy celých čísel (byte, word, shorting, integer, longint) ׃typ char ׃typ výčet ׃typ interval Operace s ordinálními datovými typy: Operace Funkce určení předchůdce určení následníka určení ordinální hodnoty zvýšení hodnoty snížení hodnoty
byte word shorting integer longint
Příklad
pred(x) succ(x) ord(x) inc(x, y) dec(x, y)
Typy celých čísel: Typ Rozsah 0..255 0..65535 -128..127 -32768..32767 -2147483648..2147483647
Neordinální: ׃typy reálných čísel
pred(10)=9 succ(10)=11 ord(‘A’)=65 inc(x, 2) – zvýší hodnotu x o 2 dec(x) – sníží hodnotu x o 1
Velikost 1B 2B 1B 2B 4B
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; begin a:=succ(pondeli); //a=utery i:=ord(utery); //i=1 end.
Operace s celými čísly: Operace sčítání odečítání násobení celočíselné dělení zbytek po dělení absolutní hodnota druhá mocnina určení lichosti
Funkce + – * div mod abs(x) sqr(x) 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=‘0’..‘9’;
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 single double extended comp
2.9*10-39..1.7*1038 1.5*10-45..3.4*1038 5.0*10-324..1.7*10308 3.4*10-4932..1.1*104932 -263..263-1
6B 4B 8B 10B 8B
Operace s reálnými čísly: Operace
Funkce
sčítání odečítání násobení dělení absolutní hodnota druhá mocnina druhá odmocnina sinus cosinus arcustangens přirozený logaritmus exponenciální funkce odseknutí zaokrouhlení desetinná část celá část
+ * / abs(x) sqr(x) sqrt(x) sin(x) cos(x) arctan(x) ln(x) exp(x) trunc(x) round(x) frac(x) int(x)
Strukturované datové typy Typ pole – array ׃viz. otázka 15
Typ záznam – record ׃viz. otázka 8
Typ soubor ׃viz. otázka 19
Typ řetězec – string ׃viz. otázka 18
Typ ukazatel – pointer ׃viz. otázka 14
Typ objekt ׃viz. otázka 23
Typ množina ׃viz. otázka
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 double long double
32b 64b 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 int long
16b závisí na OS (typicky 16b) 32b
-32768..32767 -2147483648..2147483647
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 Pointer – viz. otázka 19
Pole – viz. otázka 16 a 17
Union – viz. otázka 8
Soubor – viz. otázka 19
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á
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); void main(void) { FCE(); } void FCE(void) { static int q; q++; }
Projekt A.C
B.C
int a;
extern int a;
void main(void) { }
void fce(int x) { a=a+x; }
Globální proměnné ׃je použitelná pouze v souboru, ve kterém ji definujeme 2 různé proměnné Projekt A.C
B.C
static int a;
static int a;
void main(void) { a++; }
void fce(int x) { a=a+x; }
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
– 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
void main(void) // pokud uvedeme void main(), tak compiler si defaultně dosadí do prázdné // závorky typ int { int soucet=0; soucet=Secti(2, 3); }
int Secti(int x, int y) { return x+y; }
// definice funkce
Speciální znaky: \ \n \f \t \\ \‘ \0 %%
změna běžného významu přechod na nový řádek nová stránka tabulátor ‘\’ (zpětné lomítko) ‘ (uvozovka) nulový znak % (procento)
Formáty výstupu: %c %d %ld %u %lu %f %Lf %lf %x %X %o %s %p
znak desítkové číslo typu signed int desítkové číslo typu signed long desítkové číslo typu unsigned int desítkové číslo typu unsigned long float long double double hexadecimální číslo zapsané malými písmeny hexadecimální číslo zapsané velkými písmeny oktálové číslo řetězec (pole znaků) adresa
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:
Prefixový zápis: +5, &a, *a, ++a, --a
+ ++ -! ~ & * not not @ ^
unární plus unární mínus inkrementace dekrementace logická negace (C, C++) binární negace (C, C++) operátor reference (C, C++) operátor dereference (C, C++) logická negace (Pascal) binární negace (Pascal) operátor reference (Pascal) operátor dereference (Pascal)
+5 -5 a++ a-!a ~a &a *a not a not 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: + * / % mod div /
sčítání odečítání násobení dělení zbytek po celočíselném dělení (C, C++) 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
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: || && or and xor
Pravdivostní tabulka:
logický součet (C, C++) logický součin (C, C++) logický součet (Pascal) logický součin (Pascal) exkluzivní součet (Pascal, v C není)
Bitové operátory: | & ^ or and xor
logický součet (C, C++) 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--)
A 0 1 0 1
B 0 0 1 1
A && B 0 0 0 1
A || B 0 1 1 1
A xor B
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++): = += -= *= /= %= &= |= ^=
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
a = b + c
a a a a a a a a
a=b = a + = a = a * = a / = a % = a & = a | = a ^
b b b b b b b b
Přiřazovací operátor (Pascal): a:=10; a:=a+10;
Argumenty logických výrazů se vyhodnocují zleva doprava.
operandy operátor výraz přiřazení
if ((y!=0) && (x/y
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(…); begin rekur_1(…); end; function rekur_2(…); begin 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(…); begin B(…); end; procedure B; parametry begin . . end;
// nyní se již neuvádí formální
Příklad: procedure Ahoj; // deklarace procedure Zamena(var a, b:Integer); function Math_Pi:real;
// formální parametry
procedure Ahoj; // definice begin writeln(“Ahoj”); end; procedure Text(a:String); begin writeln(a); end;
// deklarace a definice v jednom
procedure Zamena(var a, b:Integer); var p:Integer; begin p:=a; a:=b; b:=p; end; function Math_Pi:real; begin Math_Pi:=3.14 end; var x, y:Integer; begin Ahoj; Text(“nejaky text nebo promenna”); x:=5;y:=10; Zamena(x, y); // x, y jsou skutečné parametry end.
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 void main(void) { 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(); void main(void) { int x=Secti(); } int Secti() { int a, b; scanf(“%d%d”, &a, &b); return (a+b); }
Ukazatel na funkci int Secti(int a, int b); int Odecti(int a, int b); void main(void) { 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; }
12. Činnost preprocesoru jazyka C 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 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 32767 #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 void main(void) { 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”);}
void main(void) { vysledek=sqr(4); max(20); //středník nemusí být, protože blok je ukončen v definici makra }
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//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 #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
X.C
B.C
C.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
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 ׃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
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 void main(void) { int a[N]; // vytvoření 10-prvkového pole 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
9
3
-6
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
Plnění pole
Naplnění pole při jeho vytvoření
int a[10]; int i;
int a[5]={0 20 40 60 80};
for (i=0; i<10; i++) a[i]=random(50);
Třídění pole, viz. otázka 21 int a[10]; int i, j;
Vypsání pole int a[10]; int i; for (i=0; i<10; i++) printf(“%d\n”, a[i]);
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; }
Kopírování pole
Porovnání pole
x=y;
x==y;
// nelze; x, y jsou konstantní adresy pole
for (i=0; i<10; i++) x[i]=y[i];
// nelze
for (i=0; i<10; i++) if (x[i]==y[i]) break;
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); p[0]==*p; p[1]==*(p+1);
// vytvoření 10-prvkového pole
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];
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[0]
p==p[0]==&p[0][0]; p[0][[3]=5; // lze, uloží se do p[1][0]
p[1]
p
5 p[0][0]
p[1][0]
Dynamické pole Pole pointerů (dynamické pole) ׃v době překladu musí být znám počet řádků
p[0] p
// 2 řádky
int *p[2];
p[1]
p[0]=(int*)malloc(sizeof(int)*3); p[1]=(int*)malloc(sizeof(int)*3); p[0][3]=5;
p[1][0]
// nelze
free(p[0]); free(p[1]);
5 p[0][1]
Pointer na pole (dynamické pole) ׃v době překladu musí být znám počet sloupců int (*p)[3];
p
// 3 sloupce
p=(int(*)[])malloc(sizeof(int)*2*3); p[0][3]=5;
p[0]
p[1] 5
// lze p[0][0]
p[1][0]
free(p);
Pointer na pointer (dynamické pole) ׃v době překladu neznáme počet sloupců, ani počet řádků p[0]
int **p; p=(int**)malloc(sizeof(int*)*2);
p[1]
p
p[0]=(int*)malloc(sizeof(int)*3); p[1]=(int*)malloc(sizeof(int)*3); p[0][3]=5; free(p[0]); free(p[1]); free(p);
// nelze
p[1][0] 5 p[0][1]
Dvojrozměrné pole jako parametr funkce int Maximum(int p[][3]); int Maximum(int (*p)[2]); int Maximum(int **p);
// name počet řádků pole // známe počet sloupců pole
// neznáme počet řádků, ani sloupců pole
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: void main(void) { char zn=‘x’; zn=32; zn=‘ ’;
// mezera // mezera
zn=getch();
// 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ů
Práce se znakem:
var zn:char; begin zn:=’’’’; end.
var zn:char; begin 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”; // automaticky nastaví délku char s[10]=“AHOJ”; A
H
O
J
\0
0
1
2
3
4
5
6
7
8
9
void main(void) { char s[5]; s=“AHOJ”; }
// nelze, s je konstantní ukazatel
Dynamický řetězec void main(void) { 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 void main(void) { 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
Řetězcová x znaková konstanta
char *s;
char *p; “a”
‘a’
s=(char*)malloc(sizeof(char)*10); s[0]= ‘\0’;
velikost: 2B obsahuje \0
p=NULL;
velikost: 1B
Funkce pro práci s řetězci jsou v hlavičkovém souboru STRING.H Kopírování řetězce:
Zjištění délky řetězce:
void main(void) { char s1[5]; char *s2=“text”
void main(void) { char *s=“text”; int delka;
// strcpy(cíl, zdroj); strcpy(s1, s2); }
// nepočítá se \0 delka=strlen(s); }
Spojení 2 řetezců:
char *strupr(char *s);
Převedení na malé znaky: char *strlwr(char *s);
Porovnání 2 řetězců:
void main(void) { char s[20]=“Borland”; char s2[3]=“ C”; strcat(s, s2);
Převedení na velké znaky:
void main(void) { char s1[4]=“ABC”; char s2[4]=“ABD”; int i;
// s==“Borland C”;
}
i=strcmp(s1, s2); }
Převod řetězců na čísla: int atoi(char *string); long atoil(char *string); double atof(char *string);
Návratové hodnoty: i<0 s1<s2 i=0 s1==s2 i>0 s1>s2
// i<0
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ů begin a:=‘text’; // lze ReadLn(a); WriteLn(a); end.
Spojení řetězců: var a, b, c, v:string; begin a:=‘Borland’; b:=‘ ’; c:=‘C’ v:=a+b+c end.
// v=Borland C
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ů pomocí funkce: ׃je-li výsledek delší než 255 znaků, je zkrácen na tuto délku var a, b, c, v:string; begin 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ě
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 r+ w+ a+ rb wb ab
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 otevření souboru pro čtení a zápis otevření souboru pro zápis a čtení otevření souboru pro čtení a připojení dat na jeho konec 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 void main(void) { 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
Zápis 1 znaku
void main(void) { FILE *fr; char c;
void main(void) { FILE *fw; char c=‘x’;
// soubor obsahuje abecedu fr=fopen(“x.txt”, “r”);
fr=fopen(“x.txt”, “w”); putc(c, fr);
c=getc(fr); c=getc(fr); }
// c=‘a’ // c=‘b’
}
// zapíše do souboru ‘x’
Formátované čtení ze souboru
Formátovaný zápis do souboru
void main(void) { FILE *fr; int a, b, c;
void main(void) { FILE *fw; int a=1, b=2, c=3;
fr=fopen(“x.txt”, “r”);
fw=fopen(“x.txt”, “w”);
// přečtení 3 čísel ze souboru fscanf(fr, “%d%d%d”, &a, &b, &c);
// zápis 3 čísel do souboru fprintf(fw, “%d%d%d”, a, b, c);
}
}
fscanf(f, “formát”, argumenty);
fprintf(f, “formát”, argumenty);
Ukončení práce se souborem fclose(f); fflush(f);
// data se přesunou z bufferu do souboru + uzavření souboru // 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) printf(“%d”, c);
// c musí být typu int, protože EOF=-1
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)
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).
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ů ׃n2, n*log2x
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
Bubble sort Bubble sort
5872
// třízená posloupnost
I = 1..N-1
5872 5782 5728
// i=1, j=1 // i=1, j=2 // i=1, j=3
5728 5278 5278
// i=2, j=1 // i=2, j=2 // i=2, j=3
2578 2578 2578
// i=3, j=1 // i=3, j=2 // i=3, j=3
J = 1..N-1
A[j]>A[j+1]
J++ I++ Konec
Výměna(A[j], A[j+1])
23. Základy OOP 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á)
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
Polymorfismus (vícetvárnost)
Vícenásobná dědičnost ׃potomek má více než jednoho předka
Opakovaná dědičnost
24. Delphi 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
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.
25. Prostředí jazyka Delphi Integrované prostředí jazyka Delphi obsahuje: 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
