Chceme umět rychle a efektivně programovat,
je tedy zbytečně programovat věci, které za nás udělal někdo jiný.
Jinými slovy, teprve znalost a poznávání programovacích jednotek a jejich příkazů dělá programátora programátorem.
Začneme s tou nejobsáhlejší jednotkou a podíváme se na její procedury a funkce:
Nejběžněji používané příkazy jsou obsaženy v jednotce
System. Její použití se předpokládá v každém programu, takže se System
neuvádí v sekci uses.
Uvedeme si pouze příkazy, které budeme umět využít, naučte
se z nich ty, které považujete za užitečné. Myslím si, že by s jejich použitím
neměl být sebemenší problém. Většinu procedur a funkcí totiž již známe. Připomínám, že je-li uveden výsledný typ,
jedná se o funkci, procedury nemají výsledný typ a píši za nimi středník. Není-li uveden typ proměnných,
můžeme dosadit jakýkoliv typ, který má logicky smysl.
Umožňují zpracovat matematické výrazy.
- Round(x):longint - zaokrouhlí x
- Trunc(x):longint - celá část x
- Frac(x):Real - desetinná část x
- Int(x):Real - Zaokrouhlí x. Výsledným typem je ovšem Real !!!
- Abs(x : ČíselnýTyp) : ČíselnýTyp - absolutní
hodnota z x, výsledný typ je stejný, jako má původní číslo
- Pi : Real - známé číslo (3,1415...)
- ArcTan(x):Real - ArcusTangens z x (Tan-1 x)-
výsledek je v radiánech
- Cos(x):Real - Cosinus (x je v radiánech)
- Sin(x):Real - Sinus (x v radiánech)
- Sqr(x):Real - druhá mocnina
- Sqrt(x):Real - druhá odmocnina
- Exp(x):Real - ex
- Ln(x):Real - přirozený logaritmus z x
- Randomize; Nastaví generátor náhodných čísel
- Random : Real Generuje náhodné číslo z intervalu
<0,1)
- Random(n) : Longint Generuje náhodné přirozené
číslo menší než n (může vygenerovat i nulu)
Pozn: Používáme-li instrukce koprocesoru, je místo Realu výsledným
typem typ Extended.
Převádí mezi sebou různé typy proměnných.
- Chr(x) : char - vrátí x-tý znak v ASCII tabulce
- Ord(x) : longint - vrátí o kolikátý znak daného
typu se jedná (počítáno od nuly)
- UpCase(x):char - převede písmeno na velké
- Round(x):Longint - zaokrouhlí reálné číslo
- Trunc(x):Longint - celá část reálného čísla
- Str(x:číslo,var s:řetězec); - procedura převede reálné číslo x na
řetězec znaků s. (lze zde použít notace x : PočetMíst, x:PočetMíst:PočetMístZaDesetinnou)
- Val(s:retezec,var v:Real,var c:word); Procedura převede řetězec s na reálné
číslo v (=proměnná) (tj. z '12.3' udělá 12.3). V případě chyby vrátí v c u kolikátého znaku
došlo k chybě
Umožňují lepší zpracování ordinálních proměnných. Uvědomte
si, že word se skládá ze dvou bytů.
- Ord(x):longint - vrací ordinální číslo znaku
- Pred(x):ordinal - vrací předchůdce dané hodnoty
- Succ(x):ordinal - vrací následovníka hodnoty
- Low(x):ordinal - nejnižší možná hodnota, kterou
může x (proměnná či typ) nabývat. V případě, že se jedná o pole,
udává jeho nejnižší možný index, jde-li o řetězec je výsledkem
nula
- High(x):ordinal - nejvyšší možná hodnota, kterou
může x nabýt, jde-li o pole, udává jeho nejvyšší možná index, jedná-li
se o řetězec jeho definovanou délku
- Odd(x):Boolean - Testuje, je-li x liché, či sudé
(x je celé číslo)
- Inc(x); Procedura zvýší hodnotu celého čísla x
o 1
- Inc(x,n); Procedura zvýší hodnotu celého čísla
o n
- Dec(x); Procedura sníží o 1 hodnotu proměnné x.
- Dec(x,n); Procedura sníží hodnotu x o n.
- Lo(x:Word či Integer):Byte funkce vrací nižší
byte argumentu
- Hi(x:Word či Integer):Byte funkce vrací vyšší
byte argumentu
- Swap(x : Word či Integer):Word či Integer; Funkce
prohodí horní a dolní byte argumentu.
Pozn: Procedury Inc a Dec jsou o něco rychlejší než tradiční přiřazení, ale snižují přehlednost.
Usnadňují práci s řetězcovými proměnnými.
- Concat(a,b,c,...):string spojí řetězce do jediného (lepší než
x:=a+b+c+...); Pochopitelně lze zadat i samotný řetězec (Write(Concat('a'));)
- Copy(s,od,pocet):string vrací podřetězec řetězce s, začíná
přitom od od a vyplivne pocet znaků
- Delete(s,od,pocet); Procedura vymaže z řetězce s pocet znaků
(začne
od od)
- Insert(v,r,kam); Procedura vloží na místo kam do řetězce r řetězec
v.
- Pos(subs,s):byte; Najde, kde se v řetězci s nachází podřetězec
subs; nenajde-li zadaný řetězec, vrací nulu
- Length(s):integer vrací skutečnou délku řetězce
- Str(x,s); Převede číslo x na řetězec s
- Val(s,var v,c); Převede řetězec s na číslo v, pokud se
vyskytne chyba, je číslo prvního chybného znaku uloženo v proměnné c;
Umožňují různé triky v řízení programu.
- Break; Procedura okamžitě ukončí právě probíhající
cyklus
- Continue; Přejde na konec cyklu (a buď ho vykoná
od začátku, nebo skončí)
- Exit; Ukončí podprogram (=probíhající proceduru)
- Halt; Okamžitě ukončí program
- Halt(n); Ukončí program a jako výstupní hodnotu (ERRORLEVEL) udá n
- RunError; Ukončí program tím, že vyvolá chybu 0
- RunError(n); Ukončí program vyvoláním chyby s číslem n
Bez nich by to v programování snad ani nešlo. Využívají se
všude - především k vytváření a práci s dynamickými seznamy dat.
- Assigned(P) : Boolean Ukazuje P na něco? (stejné a přehlednější je P <> nil)
- Addr(x):pointer Vrací ukazatel (adresu) na proměnnou x, stejné je @x.
- New(p); vytvoří novou dynamickou proměnnou a nastaví na ni ukazatel p
- Dispose(p); zruší dynamickou proměnnou, na kterou ukazuje p.
Občas se hodí, když si data uložíme a občas, pokud je zase
smažeme. Pozn. s zde všude znamená řetězec typu 'C:\Programy\Nesmysly\...')
- ChDir(s); nastaví aktuální adresář (složku) na s (s je název složky v systému MS-DOS)
- GetDir(d:Byte,var s:string); Procedura uloží do řetězce
s aktuální adresář. Parametr d udává, o který disk se zajímáme (0 -
současný, 1 - A:, 2 - B: ...)
- MkDir(s); vytvoří novou složku s názvem s
- RmDir(s); smaže prázdný adresář s
- Assign(f,s); přiřadí proměnné f externí soubor s názvem s
- Erase(f); smaže soubor přiřazený k proměnné f.
f nesmí být otevřen ani pro čtení ani pro zápis
- Rename(f,s); přejmenuje externí soubor přiřazený
k proměnné f na s. f nesmí být otevřen
- Reset(f); Otevře soubor pro čtení
- Rewrite(f); Otevře soubor pro zápis
- Close(f); Uzavře libovolný otevřený soubor
- Append(f); otevře textový soubor pro zápis, ale
nesmaže přitom předchozí znaky
- Write(f,x); zapíše do souboru f hodnotu proměnné x
- Writeln(f,x); Totéž, ale zapíše znak konce řádku (u textových souborů)
- Read(f,x); Přečte hodnotu ze souboru a uloží ji do proměnné x.
- Readln(f,x); Totéž, ale po přečtení hodnoty přejde na další řádek
- Eof(f):Boolean Funkce testuje, zda nenastal konec souboru
- Eoln(f):Boolean Funkce u textového souboru testuje, nejsme-li na konci řádky
Některé procedury a funkce jednotky Sys ovšem nelze zařadit do
předcházejících kategorií:
- ParamCount : Word funkce vrací počet parametrů,
které měl program v příkazové řádce (spustíte-li ho pod dosem např. jako
prince megahit makinit) bude toto číslo rovno dvěma...
- ParamStr(I:Byte) : string vrací hodnotu I-tého parametrů ParamStr(1) = 'megahit'
- SizeOf(X):longint; vrací, kolik místa v paměti zabírá X (X může být proměnná či typ)
- Include(S,P); zařadí do množiny S prvek P (P musí náležet vhodnému (=bázovému) typu)
- Exclude(S,P); vyřadí z množiny S prvek P (P musí být bázového typu)
Pozn. Include a Exclude jsou oproti S:=S±[P] o vlásek výhodnější.
To byly některé příkazy jednotky System, všechny jsem je
neuvedl záměrně, stejně bychom nevěděli co s nimi. Např.
TypeOf(P:object type) : pointer vrací ukazatel na tabulku virtuálních
metod typu objekt
Poctivě si projděte jednotlivé příkazy (popřípadě si i
zopakujte příslušnou předchozí lekci) a napište ke každému krátký
program tak, abyste viděli, jak daný příkaz funguje. Příkazy, které vás
zaujaly, či které jsou podle vás podstatné, se naučte nazpaměť. Je toho
sice hodně, ale jestliže budete aktivně programovat, tak to za měsíc stejně
máte v krvi všechno.
DCV: Napište program, který bude simulovat náhodné
chyby.