Programování v praxi

0.Struktura programu (návěští, const, var, procedure, tělo programu), oblast existence (definiční obor) a oblast platnosti identifikátoru

 

Základní struktura programu

Program <jmné programu>;

 

{ direktivy překladače }

Uses    <seznam jednotek>

Label <deklarace návěští>     – jsou to čísla 0 až 9999 nebo identifikátory, které

se použijí v programu k určení řádku pomocí příkazu goto

Const  <deklarace konstant>

Type   <definice datových typů>

Var      <deklarace proměnných>

 

<deklarace uživatelských procedur a funkcí>

<procedure;  function;>

 

Begin

<tělo hlavního programu>

End.

 

Základní pojmy

 

1. Identifikátory

Jazyk Pascal nabízí několik druhů indentifikátorů, speciálních znaků a klíčových slov. Mezi speciální symboly patří jedno a dvojznakové symboly ( + – := () : ; ) a klíčová slova ( begin end if then repeat while ).

 

Identifikátory se používají jako jména proměnných, konstant, datových typů, procedur. Určité identifikátory jsou definovány přímo v jazyku Pascal, např. integer, real, write, repeat,  a nazývají se standardní (předdefinované). Ty ostatní si programátor definuje sám.

 

Z hlediska oblasti platnosti identifikátorů se dělí na globální a lokální. Globální identifikátory jsou definovány pro celý program, lokální identifikátory jsou definovány pouze pro určitou část programu.

 

2. Konstanty

Konstanty označují hodnoty, jejichž hodnota je známa již při psaní programu a nebude se v průběhu programu měnit.

Const

Maximu = 50;

Minimum = -50;           nebo    minimum = -maximum;

Každá konstanta je nějakého datového typu a pro určení tohoto typu platí následující pravidla:

• Číslo bez znaménka, které obsahuje pouze číslice, je typu integer, jinak je typu real
• Označuje-li znakový literál jeden znak, je konstanta typu char, označuje-li posloupnost n znaků (n>1), je konstanta typu řetězec délky n

 

3. Proměnné

Proměnné jsou na rozdíl od konstant takové datové objekty, které se mohou v průběhu výpočtu měnit. Každá proměnná je určitéh typu a tímto typem je také dána množina přípustných hodnot proměnné. Datový typ proměnné a její identifikátor se deklarují v deklarační části.

Var

Maximum: integer;

Rozhodnuti: boolean;

Nadefinování hodnot se provede pomocí přiřazovacího příkazu a také příkazu vstupu.

Maximum:= 100;      – proměnná maximum bude mít hodnotu 100 dokud program neskončí nebo dokud jiný přiřazovací příkaz nebo příkaz vstupu nezmění hodnotu proměnné.

 

4. Datové typy

Datový typ definuje v programování druh proměnných. Je určen oborem hodnot a zároveň výpočetními operacemi, které lze s daty provádět.

 

1) Vizuální objekty,vstup a výstup dat, konverzní funkce; ukazatel, třída, objekty, dědičnost

 

C++ je objektově orientovaný programovací jazyk. C++ podporuje několik programovacích stylů jako je procedurální programování, objektově orientované programování a generické programování, není tedy jazykem čistě objektovým. V současné době patří C++ mezi nejrozšířenější programovací jazyky.

 

Objekty

Objekt si „pamatuje“ svůj stav (v podobě dat čili atributů) a poskytuje rozhraní operací, aby se s ním mohlo pracovat (nazývané metody). Při používání objektu nás zajímá, jaké operace (služby) poskytuje, ale ne, jakým způsobem to provádí – to je princip zapouzdření. Jestli to provádí sám nebo využije služeb jiných objektů, je celkem jedno. Vlastní implementaci pak můžeme změnit (např. zefektivnit), aniž by se to dotklo všech, kteří objekt používají.

Zapouzdření v objektech znamená, že k obsahu se nedostane nikdo jiný, než sám vlastník. Navenek se objekt projeví jen svým rozhraním (operacemi, metodami) a komunikačním protokolem.

Protokol je standard, podle kterého probíhá elektronická komunikace a přenos dat mezi dvěma koncovými body.

Atribut je rozlišovací rys, podstatná vlastnost nějakého objektu.

Abstrakce (=popis, forma poznání) objektu, která v architektuře programu podchycuje na obecné úrovni podstatu všech objektů podobného typu, se nazývá třída. Třída je předpis, jak vyrobit objekt daného typu. Třída má své atributy a metody.

Například má sousedka (chápejme ji jako objekt) má nějaké jméno, je nějak vysoká, umí chodit a umí mluvit. Totéž platí i pro mne. Mohu tedy při modelování těchto dvou objektů, sousedky a mě, abstrahovat od nepodstatných dílčích odlišností a díky této abstrakci vytvořit obecnou třídu Člověk, která bude mít atributy jméno a příjmení (obojí je nějaký řetězec znaků) a metody chodit a mluvit.

Třída je základní konstrukční prvek objektově orientovaného programování sloužící jako továrna na objekty. Definuje jejich vlastnosti a metody. Vlastnosti mohou odlišovat jednotlivé objekty, např. u objektu člověk to mohou být jméno, věk, výška, pohlaví aj. Metody určují chování objektu, to čeho je schopný, např. udělej úkoly, zavři okno aj.

Každá třída obsahuje procedury, funkce a proměnné.

Třídu definujeme pomocí klíčového slova class. Vetšinou se v třídě vypisují jen názvy a parametry metod. Implementace (= uskutečnění, naplnění, realizace) funkcí se dělá mimo třídu. Určení chovaní třídy ke svému okolí se definuje pomocí private a public. Private určuje, že zvenčí nebude daná část třídy viditelná. Public zase naopak zpřístupňuje vše.

Funkce popisují co lze s daným objektem dělat.

Proměnné slouží k popisu vlastnosti objektu.

Metody  jsou procedury a funkce.

 

Ukazatel

Ukazatel je datový typ, který slouží k uložení adresy v paměti počítače.

Každá proměnná, kterou deklarujeme, se nachází v paměti počítače, která je rozdělena na buňky o velikosti 1 bytu. Každá buňka má nějaké číslo, pomocí kterého ji lze jednoznačně určit. Tomuto číslu se říká adresa. Ukazatelem je možné číst nebo měnit hodnotu na adese kam ukazuje.

Int a;                      //definice proměnné a datového typu integer

Int *pInt;               //pInt je ukazatel na proměnnou typu integer

pInt = &a;             //ukazateli přiřadíme adresu proměnné a

*pInt = 2;              //měníme hodnotu na adrese, kam ukazatel ukazuje

Cout << *pInt;      // vypíše se hodnota 2

 

Dědičnost

Hlavní myšlenka dědičnosti je znovupoužitelnost, to znamená, že můžeme vytvářet nové třídy založené na třídě, která již byla definována, místo toho abychom museli znovu psát již jednou napsaný kód jen s jinými typy proměnných. Díky dědičnosti je možné napsat kód jednou pro obecnější typ a poté ho používat pro všechny jeho potomky. Všechny objekty předchozí třídy zůstanou zachovány a pouze se rozšíří o nové. Každá třída ma konstruktor Create

Kontruktor je metoda třídy, která se volá, když je instance  příslušného objektu této třídy nově vytvářena.

Inheritance umožňuje přidat k základní třídě T1 další vlastnosti nebo stávající vlastnosti modifikovat a vytvořit novou odvozenou (podtřídu neboli potomka) třídu T2.

Programovací jazyk C++ umožňuje vytvářet inheritanci typů:

• Jednoduchá inheritance – třída má jen jednoho předka (rodiče). Vytváříme stromovou hierarchii tříd. Třídu s nejvyšší úrovní označujeme jako kořenovou třídu.

• Vícenásobná inheritance – třída má více předků
• Opakovaná inheritance – třída může zdědit vlastnosti některého (vzdálenějšího) předka více cestami. Vztahy tříd jsou znázorňovány grafem příbznosti tříd.

 

Class T1 {

Private: //soukromé datové prvky

Public: //veřejně přístupné metody

}

Class T2: public T1 {//třída T2 je potomkem třídy T1

Private:

Public:

}

 

Vstup a výstup dat

Každý program při svém spuštění dostane od operačního systému standardní vstup (klávesnice) stdin, výstup (monitor) stdout a chybový výstup (monitor) stderr.

 

Funkce, které s těmito vstupy a výstupy pracují jsou definované v hlavičkovém souboru <stdio.h>

 

Vstupní a výstupní zařízení lze rozdělit na znaková (klávesnice a monitor) a bloková (pevný disk). Rozdíl je především v možnosti získávání či vkládání dat z/do zařízení. Ke znakovým zařízením se přistupuje sekvenčně, tedy znak po znaku, a k blokovým náhodným přístupem, tedy dle libosti z kterékoliv části disku.

 

2) Datové typy jednoduché: rozdělení, deklarace v různých programovacích jazycích

 

Datový typ definuje v programování druh proměnných. Je určen oborem hodnot a zároveň výpočetními operacemi, které lze s daty provádět.

 

Jednoduché datové typy nemají vnitřní strukturu. Složitější typy jsou ve skutečnosti složeny z těchto základních

• Logická hodnota (boolean) – true nebo false (1 nebo 0) zabírá 1 byte
• Celé číslo (integer) – např. 256, 0, -100, 0xA9 (hex zápis) zabírá 4 byty
• Znak (char) – právě 1 znak mezi apostrofy; např. ‚a‘, ‚5‘, ‚%‘, …
• Výčet zabírá 1 byte

 

Tyto typy jsou ordinální – hodnoty tohoto typu tvoří lineárně uspořádanou množinu, kde pro každý prvek je přesně definovaný předchůdce i následovník (z posledního prvku dojde k tzv. přetečení na první).

 

• Reálné číslo – číslo s plovoucí řádovou čárkou (float, real) – 3.14, 0.5                     zabírá 6 bytů

– obsahuje . nebo E – např. 23000 = 23E3 = 2.3E4 = 2.300000E+04

– skládá se ze 2 částí: mantisa a exponent

 

Tyto typy se dělí na dvě základní skupiny a to ordinální a neordinální.

 

Ordinální

Ordinální datové typy se vyznačují tím, že jejich hodnoty jsou uspořádány podle

velikosti od nejmenšího po největší. Je tedy znám počet hodnot každého datového

typu. Hodnoty datového typu jsou zobrazitelné na množině celých čísel.

 

Neordinální

Hodnoty takového typu nejsou zobrazitelné na množině celých čísel. Mezi neordinální datové typy patří datový typ pro popis racionálního čísla, tedy čísla, jehož počet desetinných míst je konečný.

 

Ordinální        velikost paměti             rozsah              Neordinální                rozsah

– Integer           – 32 bitů se znaménkem           – 0-255                       – Real48          11-12 přesnost; 6 bytů

– Word                        – 16 bitů bez znaménka            – 0-65535        – Double          15-16 přesnost; 8 bytů

– Byte              – 8 bitů bez znaménka

– Word                        – 16 bitů bez znaménka

 

Deklarace:

 

C++                                                                           Delphi

var

Int cislo;                                                                      cislo: integer;

Double r;                                                                    R: real;

WString text;                                                              text: string

Char c;

Výčet

Výčet je jednoduchý datový typ, který si uživatel může definovat podle svých požadavků. jednotlivé hodnoty mají svá ordinální čísla podle pořadí v zápisu a jejich počítání začíná nulou.

Type

Tyden = (pondeli, utery, streda, ctvrtek, patek, sobota, nedele)

Obdobi = (jaro, leto, podzim, zima)

Var

Den: tyden;

Doba: obdobi;

 

3) Datové typy strukturované – pole: deklarace v různých programovacích jazycích, rozdíly

 

Datový typ definuje v programování druh proměnných. Je určen oborem hodnot a zároveň výpočetními operacemi, které lze s daty provádět.

 

Strukturovaný datový typ je v podstatě skupina jednodušších typů a proměnná strukturovaného datového typu je skupina proměnných nějakého jednoduššího typu. Každý strukturovaný datový typ poskytuje prostředky pro práci s prvky dat, tj. pro jejich zpřístupnění.

 

Datový typ pole

Tento datový typ se skládá z pevného počtu položek stejného typu. Položky se vzájemně rozlišují pomocí indexu. Mezi položkami dat a hodnotami indexů existuje jednoznačné přiřazení. Při definici pole se určuje jeho rozměr a datový typ složek. Rozměr pole určuje počet prvků, které se do pole mohou vložit. Index pole je většinou typu integer. Může jím však být i jiný ordinální typ. Velikost pole je vždy omezena paměťovými nároky.

 

Pole se deklaruje klíčovým slovem „array„. Za ním je uveden rozsah uzavřený do hranatých závorek. Následuje klíčové slovo „of“ a typ proměnné. Když chceme do proměnné v poli přiřadit hodnotu, tak se zase index proměnné píše do hranatých závorek.

Jednorozměrné pole se nazývá vektor.

 

Type

pole1 = array[1..3] of integer;

pole2 = array[1..20] of char

var

cislo_domu: pole1;

jmeno: pole2;

begin

pole1[1]:=10;

pole1[2]:=20;

pole1[3]:=30;

end;

 

Definice pole pouze pro jednu proměnnou:

var

cislo_domu: array[1..3] of integer;

jmeno: array[1..50] of char;

 

Při práci s tabulkami nebo jakýmikoliv souřadnicovými systémy se používá dvourozměrné pole. Nedeklarují se zde 2 argumenty, ale 4. Vícerozměrné pole označujeme jako matici.

 

var                                                     První dva argumenty udávají rozsah pole na osu x

pole:array[1..3, 1..3] of integer;                      a druhé dva na osu y.

begin

pole[1,1]:=50;

pole[1,2]:=20;

end;

 

Příklad

Vytvořte program, který bude sčítat výrobu podniků A a B za jednotlivé měsíce roku; výsledek uloží do pole Celkem.

Platí deklarace:

const Min=1;

Max=12;

type Vyroba=array[Min..Max] of Real;

var

A, B, Celkem: Vyroba;

i: Integer;

Část programu, která sečte výrobu podniků A a B a výsledek uloží do pole Celkem.

i:=Min;

while i<=Max do

begin

Celkem[i]:=A[i]+B[i];

i:=i+1;

end;

 

Homogenní datový typ

Datový typ obsahuje jeden nebo více prvků a jsou stejného typu.

Var

Pole:array[20,-5] of integer;                pole[1]= -5

Textový řetězec – ‚‚Ahoj‘‘                retezec[0]= A

Výčtový typ (enum)    enum barva{piky,srdce,kary,krize};

 

Heterogenní datový typ

Je složen z prvků různých datových typů a navenek se chová jako kompaktní celek.

Pascal – record

C++ – struct               typedef struct {int vek;

Char *jmeno;

Enum {muz, zena} pohlavi;

• Seznam (list) – obdoba pole   } osoba;

 

Statické pole

Je nutné znát počet prvků během překladu.

C++     int pole[10];                                        Pascal  pole:array[0..9] of integer;

Int pole[10]={0,1,2,3,4,5,6,7,8,9};

 

Dynamické pole

Není nutné znát během překladů počet prvků, můžeme je vyalokovat (=přiřazení zdrojů) až při samotném běhu programu. Při překladu je ovšem nutné znát bázový typ pole.

C++               int *pole;                                             Pascal

Alokace pole:   pole=(int *)malloc(sizeof(int)*10);       type

Uvolnění pole:  free(pole);                                           Dpole = array of integer;

Zakotvení pole:            pole=NULL;                                       var

Form1: Tform1;

Anonymní pole                                                          p1, p2: Dpole;  // dynamické  pojmenované pole

Není nijak pojmenováno.

Pascal

Var

Form1: Tform1;

P1, p2: array [0..9] of integer   // statické anonymní

 

4) Datové typy strukturované – záznam: deklarace v různých programovacích jazycích, použití příkazu WITH

 

Datový typ definuje v programování druh proměnných. Je určen oborem hodnot a zároveň výpočetními operacemi, které lze s daty provádět.

 

Strukturovaný datový typ je v podstatě skupina jednodušších typů a proměnná strukturovaného datového typu je skupina proměnných nějakého jednoduššího typu. Každý strukturovaný datový typ poskytuje prostředky pro práci s prvky dat, tj. pro jejich zpřístupnění.

 

Datový typ záznam

Tento datový typ se skládá z určitého počtu položek, které mohou být různého typu. Každá položka má přiděleno jméno, neboli identifikátor položky, pomocí něhož se provádí výběr položky.

Příklad1:

Pascal

K jednotlivým položkám se přistupuje pomocí tečky.

Type zaznam =            record

Jmeno, prijmeni, telefon, adresa:string;

Vek:integer;

End;

Var prom: zaznam;

Begin

Prom.jmeno:= ‚petr‘;

Prom.prijmeni:= ‚novak‘;

Prom.telefon:= ‚723259575‘;

Prom.adresa:= ‚U salonu 25′;

Prom.vek:= ’20‘;

End;

 

Použití with – usnadnění přístupu k jednotlivým položkám.

 

Type zaznam =            record

Jmeno, prijmeni, telefon, adresa:string;

Vek:integer;

End;

Var prom: zaznam;

Begin

With prom do

Begin

Prom.jmeno:= ‚petr‘;

prijmeni:= ‚novak‘;

telefon:= ‚723259575‘;

adresa:= ‚U salonu 25′;

vek:= ’20‘;

 

End;

End;

 

type zaznam=record

jmeno: string;

prijmeni: string;

vek: integer

end;

 

Příklad2:

type pole=array[0..2] of zaznam;

 

var

Form1: TForm1;

polozka: pole;

a: integer;

implementation

 

procedure TForm1.FormCreate(Sender: TObject);

begin

a:=0;

polozka[0].jmeno:=’Jiří‘;

polozka[0].prijmeni:=’Vích‘;

polozka[0].vek:=18;

 

polozka[1].jmeno:=’Filip‘;

polozka[1].prijmeni:=’Krišpín‘;

polozka[1].vek:=17;

 

polozka[2].jmeno:=’Kateřina‘;

polozka[2].prijmeni:=’Víchová‘;

polozka[2].vek:=16;

 

end;

 

Variantní záznamy

Záznamy, které mají ve své struktuře ještě navíc variantní část. Definujeme takové typy, které jsou pouze varianty téhož typu.

Příklad:

Type informace = record

Jmeno, prijmeni: array[1..15] of char;

Datum_narozeni:datum;

Case pohlavi: (muz, zena) of

Muz: (  vaha:real;

Vousy:boolean);

Zena: ( miry: array[1..3] of integer);

End;

 

C++

Typedef struct veta {

Int cist21;

Char text21;

Char text22;

Char text23;

Int cis22;

Double cisd2;

};

 

5) Datové typy strukturované – soubor: deklarace v různých programovacích jazycích, odlišnosti jednotlivých typů souborů

 

V programu je soubor identifikován pomocí proměnné některého ze souborových typů, v jejíž vnitřní struktuře jsou zakódovány údaje o aktuálním stavu souboru.

 

Soubory:

• Textové – soubor pro uchovávání prostého elektronického textu. Text je zde reprezentován prostou sekvencí znaků, textový soubor není vnitřně strukturovaný.

 

• Binární – soubor, který obsahuje jakákoliv data, která jsou následně zpracovávána počítačovým programem. Obsahem souboru jsou čísla v binární soustavě (řetězec nul a jedniček), která reprezentují jistým způsobem uloženou informaci, což může být zvuk, obrázek, video

 

• amorfní

 

Typ soubor tvoří posloupnost položek typu složka. Složky mohou být libovolného datového typu kromě typu soubor a strukturovaného typu se složkou typu soubor. Deklarace v programu vypadá takto:

Type

Soubor = file of složka;

 

Soubor je v programu definován jako proměnná, u které se musí určit typ. U souborů rozlišujeme 3 typy:

• Soubor s udaným typem       např. binární soubor

Var

Soubor_cisel: file of integer;

 

• Textové soubory – znaky jsou organizovány do řádků

var

Soubor_znaku: TextFile;

 

• Soubory bez udaného typu – netypové soubory – používají se ve vstupně/výstupních operacích pro přístup k diskovému souboru bez ohledu na jeho vnitřní formát.

var

Netypovy_soubor: file;

var  f: file of char;  c: char; begin  …  Read(f, c);  …  Write(f, c);  …end. Pascal

Binární soubory

var

soubor: file of integer;

soubor: file of real;

Assignfile (soubor, ‚muj.bin ‚);

 

Reset (soubor);                                  otevře existující soubor pro čtení i zápis

Rewrite (soubor);                   otevře prázdný soubor pro čtení i zápis

Read (soubor, <proměnná>);  načte ze souboru hodnotu do proměnné

Write (soubor, <proměnná>;  zapíše do souboru hodnotu proměnné

Eof (soubor);                           vrací hodnotu True v případě, že bylo dosaženo konce souboru

Seek (soubor, <pozice>);        tato procedura přemístí kurzor v souboru na pložku, která je na zadané pozici

Filepos (soubor);                     vrátí aktuální pozici v souboru

Filesize (soubor);                     vrátí velikost souboru

Truncate (soubor);                   odstrané zbytek souboru od aktuální pozice v souboru

Closefile(soubor);                  zavření souboru

 

Textové soubory

Čtení

Var

Soubor: TextFile;

Jmeno: string;                         deklarace proměnné pro přístup k souboru, pro čísla integer

Begin

AssignFile (soubor, ‚ soubor.txt‘);         přiřazení konkrétního souboru

RESET (soubor);         čtení

Nebo

REWRITE (soubor);               vytvoření souboru, pokud existuje, je smazán

Nebo

APPEND (soubor);                 otevření pro zápis na konci souboru

Práce  se souborem:

READ (soubor, jmeno);                      načte ze souboru hodnoty do proměnných

READLN (soubor, jmeno);     načte ze souboru hodnoty do proměnných, přesun na konec

WRITE (soubor, jmeno);         zapíše do souboru textovou reprezentaci hodnot

WRITELN (soubor, jmeno);    zapíše do souboru textovou reprezentaci hodnot, ukončí řádek

EOF (soubor);                         vrací hodnotu True v případě, že bylo dosaženo konce souboru

EOLN (soubor)           ;                       vrací hodnotu True v případě, že bylo dosaženo konce řádku

CloseFile (soubor);

End;

Zápis

Příklad

var soubor:      TextFile;

pom: string;      pom = pomocná proměnná

 

begin

assign(soubor, ‚muj.txt‘);          přiřadíme jméno

rewrite(soubor);                       vytvoříme soubor – nemusíme ho otvírat pomocí reset, protože funkce rewrite ho rovnou i otevře

repeat

readln(pom);                uživatel zadá text

writeln(soubor, pom);   zapíšeme text do souboru

until pom = ‚ ‚;                        dokud nebude zadáno nic

close(soubor);                         ukončíme práci se souborem

end.

 

C++

Textové soubory

Čtení

Char Buffer[80], cislo[20];                        deklarace proměnné pro přístup k souboru

FILE *soubor;

 

Soubor = fopen (‚soubor.txt‘, „rt“);             zadání cesty pro otevření souboru, „r“ znamená read

Fscanf (soubor, „%formát“, &cislo);          funkce pro čtení

Fclose (soubor);

 

Zápis

AnsiString cesta;

Char buffer[80];

FILE *soubor;

Int pocet_zapsani;

 

Zápis do souboru:

Soubor = fopen (‚soubor.txt‘, „wt“);                       w = write

Fprintf (soubor, „%s \n“, vyrazy);               fprintf (FILE *stream, const char *format, vyrazy);

const char *format = formátovací  řetězec

Počet_zapsani = počet_zapsani + 1;

Fclose(soubor);

 

Binární soubory

FILE *soubor

Soubor = fopen (‚cesta‘, ‚ rb‘);       rb = read binar

Soubor = fopen (‚cesta‘, ‚ wb‘);      wb = write binar

Fread(buffer, velikost_záznamu, počet_záznamů, soubor);

Fwrite(buffer, velikost_záznamu, počet_záznamů, soubor);

Fclose (soubor);

 

6) Základní řídící struktury – přiřazovací příkaz: rozdíl v syntaxi v různých programovacích jazycích, výraz, kompatibilita vzhledem k přiřazení

 

Přiřazovací příkaz

je jedním ze základních příkazů všech programovacích jazyků. Slouží k přiřazení nějaké hodnoty do proměnné. Jméno proměnné nazýváme také identifikátor.

Pascal                         C++

X := 2;                         x = 2;

 

Kompabilita výzhledem k přiřazení

Výraz na pravé straně musí být kompatibilní vzhledem k přířazení s typem proměnné na levé straně.

Např.   Typ H dosazované hodnoty je kompatibilní vzhledem k přiřazení s typem P

 

• H a P jsou identické typy, avšak nejsou typy soubor ani neobsahují komponentu typu soubor na žádné úrovni své struktury
• H a P jsou kompatibilní ordinální typy
• H je číselný typ, P je reálný typ
• H je řetězcový typ, pole znaků nebo znak a P je řetězcový typ
• H i P jsou kompatibilní pole znaků
• H a P jsou kompatibilní množinové typy
• H a P jsou kompatibilní ukazatelové typy
• H a P jsou kompatibilní procedurální typy

 

Výraz

1.	(     )                                                 – nejvyšší priorita
2.	not
3.	*     /     div     mod     and
4.	+     –     or
5.	=     <>     <     >     <=     >=            – nejnižší priorita

Výrazy zachycují posloupnosti operací, které se mají provést. Obsahují operandy, operátory, případně i kulaté závorky. Provedení všech operací předepsaných výrazem se nazývá vyhodnocení výrazu a výsledkem vyhodnocení výrazu je hodnota výrazu. Jednotlivé operace, předepsané výrazem, se provádějí zleva doprava s ohledem na prioritu operátorů a na závorky. Podle implementace jazyka Pascal platí tato tabulka priorit operátorů a závorek:

 

Operátory

Aritmetické                * / div mod

Logické                      OR AND XOR NOT

Relační                       = , :=

 

Operand – název pro vstupní hodnotu matematické operace nebo operátoru

Proměnná

Konstanta

 

Pascal             C++

MOD              %

DIV                 /

++

—

AND               &&

NOT               !

OR                  ||

 

7) Základní řídící struktury – podmíněný příkaz: úplný a neúplný podmíněný příkaz, syntaxe

 

Podmíněný příkaz if

Používáme, pokud potřebujeme provést nějaký příkaz jen za určitých podmínek.

Tomuto problému se říká větvení programu.

 

Neúplný podmíněný příkaz

If podmínka     then příkaz při splnění podmínky

 

Úplný podmíněný příkaz

If podmínka     then příkaz při splnění podmínky

Else příkaz při nesplnění podmínky

Var cislo: integer;

Begin

Cislo:= 5;

If cislo = 5 then write (‚Ahoj ‚);

End;

 

Pokud potřebujeme při splněné podmínce provést více příkazů, použijeme složený příkaz.

Pascal – begin–end;               C++ { }

Var cislo: integer;

Begin

Cislo:= 5;

If cislo = 5 then

Begin

write (‚Cislo je 5‘);

write (‚Cislo je skutečně 5‘);

end;

End;

 

Vývojový diagram

Vývojový diagram je grafické znázornění nějakého algoritmu nebo procesu. Vývojový diagram používá pro znázornění jednotlivých dílčích operací symboly, které jsou navzájem propojeny pomocí orientovaných šipek. Vývojový diagram má nečastější použití v informatice aprogramování.

 

• úsečka či množina navazujících úseček končící šipkou – určuje směr zpracování algoritmu
• obdélník s popisem – definuje dílčí krok zpracování algoritmu
• kosočtverec – větvení postupu v algoritmu v závislosti na splnění podmínky, viz skok
• obdélník se zaoblenými rohy – počátek nebo ukončení zpracování algoritmu
• kruh – spojka, jednotlivých úseček

 

8) Základní řídící struktury – příkaz CASE: syntaxe v různých programovacích jazycích, vývojový diagram

 

Podmíněný príkaz case

Používáme pokud potřebujeme provést mnohonásobné větvení programu na základě hodnot jedné proměnné.

Case (přepínač) rozdělí program na libovolný počet různých větví.

 

Pascal

Case proměnná of

Hodnota1: příkaz1;

Hodnota2:        begin

Příkaz2;

Příkaz3;

End;

Else

Příkaz4;           – Kód, který se provede, pokud nevyhovuje ani jedna z předchozích možností

 

Var

Cislo: integer;

Begin

Cislo:= 3;

Case cislo of

1: write (‚ cislo je 1‘);

2: write (‚ cislo je 2‘);

3:                     begin

write (‚ cislo je 3‘);

write (‚ cislo je opravdu 3‘);

End;

Else

write (‚ cislo je jine‘);

End;

 

C++

Místo case je zde switch

 

Switch (výraz)

{case hodnota1: příkaz1;

Příkaz2;

Break;

Case hodnota2: příkaz3;

Příkaz4;

Break;

Default: příkaz5;           – default – provede příkaz, pokud žádná hodnota neodpovídá

}

 

9) Základní řídící struktury – cyklus WHILE: syntaxe v různých programovacích jazycích, vývojový diagram, kdy je výhodné použití příkazu

 

Programové cykly se používá pro opakované provádění příkazů. Existují tři druhy programových cyklů.

 

1. while – do                              while = zatímco platí, do = dělej)
2. repeat – until                                     repeat = opakuj, until = dokud neplatí)
3. for – to (downto) – do                       for = pro, to = do hodnoty, downto = až do hodnoty

 

Cyklus WHILE – programový cyklus s podmínkou na začátku

 

Pascal                                                 C++

while podmínka do                             While (podmínka) { příkazy }

příkaz;

 

Tento cyklus se používá v těch případech, kde neznáme přesný počet opakování.

 

Příkaz v cyklu je prováděn tak dlouho, dokud je podmínka pravdivá (True). Když se stane nepravdivou (False), cyklus je ukončen a program pokračuje příkazem za cyklem.

Příkaz v cyklu může být také složený v bloku begin-end;

Test podmínky pro provádění cyklu je na jeho začátku.

 

V cyklu se nesmí zapomenout na zvětšování hodnoty čítače. Jinak by došlo k zacyklení, neboť by podmínka nikdy nepřestala platit.

 

Pokud je na začátku  podmínka False, tak se všechny příkazy v cyklu přeskočí a neprovede se ani jednou.

 

Pascal

Příklad:

Var

N: integer;

Begin

Writelln;

N:= 0;

While (N <5) do

Begin

Writeln (‚N =  ‚,N);

N:= N+1;

End;

Readln;

End;

 

Výsledek:

N = 0

N = 1

N = 2

N = 3

N = 4

 

C++

While (podmínka) { příkazy }

 

Pomocí příkazu continue lze přeskočit zbytek provádění těla aktuální iterace (opakování) cyklu a prokračovat následující iterací.

 

Var i: integer;

Begin                                     Tento cyklus vypíše čísla od 1 do 10 kromě šestky.

For i:= 1 to 10 begin

If i = 6 then continue;

Writel(i);

End;

End;

 

Pomocí příkazu break lze násilně ukončit cyklus z jeho těla. Jakmile se v těle cyklu vyhodnotí příkaz break, cyklus se ukončuje a pokračuje se nasledujícím příkazem za cyklem.

 

var i: integer;

begin

for i := 1 to 10 do begin

if i = 6 then break;                (* když je i 6, cyklus se ukončí *)

writeln(i);

end;
end.

 

10) Základní řídící struktury – cyklus REPEAT: syntaxe v různých programovacích jazycích, vývojový diagram, kdy je výhodné použití příkazu

 

Programové cykly se používá pro opakované provádění příkazů. Existují tři druhy programových cyklů.

 

1. while – do                              while = zatímco platí, do = dělej)
2. repeat – until                                     repeat = opakuj, until = dokud neplatí)
3. for – to (downto) – do                       for = pro, to = do hodnoty, downto = až do hodnoty

 

Cyklus REPEAT – programový cyklus s podmínkou na konci

 

Pascal                                                C++

Repeat                                                          DO

Příkaz;                                     { příkazy }

Until Podmínka;                                  While (podmínka);

 

Tento cyklus se používá v těch případech, kde neznáme přesný počet opakování.

 

Příkaz v cyklu je prováděn, pokud je podmínka nepravdivá (False). Test podmínky je proveden na konci cyklu, to znamená, že cyklus je proveden alespoň jednou. Aby byl cyklus ukončen, musí se podmínka při jeho provádění stát pravdivou.

 

Příkaz v cyklu může být také složený. Protože slova repeat a until vytvářejí již sama o sobě blok, tak begin – end; není nutné.

Repeat

…..

…..

Until (x > 15);

 

Cyklus může být také ukončen klávesou funkcí KeyPressed, ta vrací logickou hodnotu False, je-li stisknuta jakákoliv klávesa (mimo CTRL, ALT, apod.), funkce vracií hodnotu True.

 

Repeat until KeyPressed;     Funkce KeyPressed je v programové jednotce Crt. Tato jednotka musí být v programu deklarována v sekci Uses.

Pomocí příkazu continue lze přeskočit zbytek provádění těla aktuální iterace (opakování) cyklu a prokračovat následující iterací.

 

Var i: integer;

Begin                                     Tento cyklus vypíše čísla od 1 do 10 kromě šestky.

For i:= 1 to 10 begin

If i = 6 then continue;

Writel(i);

End;

End;

 

Pomocí příkazu break lze násilně ukončit cyklus z jeho těla. Jakmile se v těle cyklu vyhodnotí příkaz break, cyklus se ukončuje a pokračuje se nasledujícím příkazem za cyklem.

 

var i: integer;

begin

for i := 1 to 10 do begin

if i = 6 then break;                (* když je i 6, cyklus se ukončí *)

writeln(i);

end;
end.

 

11) Základní řídící struktury – cyklus FOR: syntaxe v různých programovacích jazycích, vývojový diagram, kdy je výhodné použití příkazu

 

Programové cykly se používá pro opakované provádění příkazů. Existují tři druhy programových cyklů.

 

1. while – do                              while = zatímco platí, do = dělej)
2. repeat – until                                     repeat = opakuj, until = dokud neplatí)
3. for – to (downto) – do                       for = pro, to = do hodnoty, downto = až do hodnoty

 

Cyklus FOR – programový cyklus s pevným počtem opakování

 

Cyklus při prvním průchodu přiřadí do čítače počáteční hodnotu. Pak provede všechny příkazy, zvětší čítač o jedničku a skočí opět na první příkaz v cyklu. To se opakuje dokud hodnota nedosáhne konečné hodnoty.

 

Pascal používá výčet intervalu

For i:= 1 to 10 do        i nabývá postupně hodnot od 1 do 10

Begin

Tělo cyklu

End;

 

C++ používá konstrukce inicializátor, podmínka, inkrement a tělo cyklu

For ( i = 1; i  <= 10; i++) {      inicializátor; podmínka; inkrement

Tělo cyklu

}

 

Pomocí příkazu continue lze přeskočit zbytek provádění těla aktuální iterace (opakování) cyklu a prokračovat následující iterací.

 

Var i: integer;

Begin                                     Tento cyklus vypíše čísla od 1 do 10 kromě šestky.

For i:= 1 to 10 begin

If i = 6 then continue;

Writel(i);

End;

End;

 

Pomocí příkazu break lze násilně ukončit cyklus z jeho těla. Jakmile se v těle cyklu vyhodnotí příkaz break, cyklus se ukončuje a pokračuje se nasledujícím příkazem za cyklem.

 

var i: integer;

begin

for i := 1 to 10 do begin

if i = 6 then break;                (* když je i 6, cyklus se ukončí *)

writeln(i);

end;
end.

 

12) Práce se soubory – čtení textových souborů: posloupnost příkazů pro úspěšnou práci s textovými soubory, příkazy pro čtení v různých programovacích jazycích, možnosti čtení

 

Soubor je pojmenovaná posloupnost bytů uložená na nějakém datovém médiu.

Každý soubor má svůj název, délku a popřípadně další atributy.

Obsahem jsou různá data (text, binární data obsahující strojový kód nějaké aplikace, obrázku).

 

Rozdělení souborů:

• Textové – soubor pro uchovávání prostého elektronického textu. Text je zde reprezentován prostou sekvencí znaků, textový soubor není vnitřně strukturovaný.

 

• Binární – soubor, který obsahuje jakákoliv data, která jsou následně zpracovávána počítačovým programem. Obsahem souboru jsou čísla v binární soustavě (řetězec nul a jedniček), která reprezentují jistým způsobem uloženou informaci, což může být zvuk, obrázek, video

 

• amorfní

 

Obecný postup při práci se soubory

• deklarace proměnné pro přístup k souboru
• přiřazení konkrétního souboru této proměnné
• otevření souboru pro čtení nebo zápis
• vlastní práce se souborem

• uzavření souboru

Proměnné při práci se soubory

• TEXTFILE                             – textové soubory
• FILE OF <typ položky>         – binární soubory
• FILE                                       – netypové soubory

 

Práce s textovými soubory

Z textových souborů lze přímo číst znaky, textové řetězce, celá a reálná čísla, číselné hodnoty jsou konvertovány z textu na číselnou hodnotu.

 

Pascal

Var

Soubor: TextFile;

Jmeno: string;                         deklarace proměnné pro přístup k souboru, pro čísla integer

Begin

AssignFile (soubor, ‚ soubor.txt‘);         přiřazení konkrétního souboru

RESET (soubor);         čtení

Nebo

REWRITE (soubor);               vytvoření souboru, pokud existuje, je smazán

Nebo

APPEND (soubor);                 otevření pro zápis na konci souboru

Práce  se souborem:

READ (soubor, jmeno);                      načte ze souboru hodnoty do proměnných

READLN (soubor, jmeno);     načte ze souboru hodnoty do proměnných, přesun na konec

WRITE (soubor, jmeno);         zapíše do souboru textovou reprezentaci hodnot

WRITELN (soubor, jmeno);    zapíše do souboru textovou reprezentaci hodnot, ukončí řádek

EOF (soubor);                         vrací hodnotu True v případě, že bylo dosaženo konce souboru

EOLN (soubor)           ;                       vrací hodnotu True v případě, že bylo dosaženo konce řádku

CloseFile (soubor);

End;

 

C++

Char Buffer[80], cislo[20];                  deklarace proměnné pro přístup k souboru

FILE *soubor;

 

Soubor = fopen (‚soubor.txt‘, „r“);        zadání cesty pro otevření souboru, „r“ znamená read

Fscanf (soubor, „%formát“, &cislo);     funkce pro čtení

Fclose (soubor);