1. PODSTAWOWE FUNKCJE EDYTORA

^- oznaczenie klawisza CTRL

STEROWANIE KURSOREM

Przemieszczenie kursora :

HOHE - na początek wiersza

END - na koniec wiersza

PgUp - o Jedną stronę w górę

PgDn - o jedną stronę w dół

^HOME - do pierwszego wiersza w okienku

^END - do ostatniego wiersza w okienku

^PgUp - na początek tekstu

^PgDn - na koniec tekstu

OPERACJE NA TEKSTACH

DEL - skasowanie znaku pokrywającego się z kursorem

INS - zmiana trybu pracy wstawianie/nadpisywanie

^H - wstawienie pustego wiersza

^Y - usunięcie wiersza

^T - usunięcie słowa z prawej strony kursora
ENTER - tworzenie nowego lub podział istniejącego wiersza
(zależnie od pozycji kursora)

OPERACJE NA BLOKACH

^KB - ustawienie znacznika początku bloku

^K K - ustawienie znacznika końca bloku

Blok można zaznaczać także przez przesuwanie kursora strzałkami przy stale wciśniętym klawiszu SHIFT.

^K C - skopiowanie bloku do obszaru wyznaczonego przez

bieżące położenie kursora

^K Y - usunięcie bloku

^K V - przeniesienie bloku do obszaru wyznaczonego przez

bieżące położenie kursora

^K H - wyłączenie podświetlenia bloku

^K W - zapisanie bloku na dysku

^K R - wczytanie bloku z dysku

^K I - przesunięcie bloku o jedną kolumnę w prawo ~K U - przesunięcie bloku o jedną kolumnę w lewo

OPERACJE WYSZUKANIA

^Q F - wyszukanie podanego ciągu znaków

^Q A - wyszukanie podanego ciągu znaków z zamianą na Inny ciąg znaków

Operacje wyszukania można także przeprowadzić wykorzystując opcję Search|Find.

^L - powtórzenie operacji wyszukania ciągu znaków lub wyszukania i zamiany

Operacje zamiany można także przeprowadzić wykorzystując opcję Serach/Beplace.

^Q L - przywrócenie usuniętego wiersza

CTRL +F9 uruchomienie programu

ALT+F5 przełączenie między ekranem TP a ekranem użytkownika

ALT+F9 kompilacja bez uruchomienia

Aby zamienić Pas na exe naciskamy ALT+C następnie wybieramy Destination Disk i F9

Podstawową operacją jaką wykonujemy na zmiennych to podstawienie np.: wiek:=29;

<zmienna> := <wyrażenie>;

użycie zmiennych musi być poprzedzone deklaracją:

var i : integer;

const stawka procentowa :=0,19

operatory arytmetyczne

* mnożenie

/ dzielenie

+ dodawanie

- odejmowanie

div dzielenie całkowite

mod reszta z dzielenia całkowitego

operatory relacyjne <,>,=,<=,>=,<>

IN zawiera się

Operatory logiczne

And (i)

Or (lub)

Not (nie)

Xor (albo…albo)

Funkcje matematyczne

Abs(x) |x|

Sqr (x) x²

Sqrt(x)

Exp(x) e^x

Ln(x)

Funkcje sprawdzające porządek

Odd(x) sprawdza czy element jest nieparzysty. Zwraca dwie wartości (true, false)

Pred(x) zwraca poprzedni element

Succ(x) zwraca następny element

Funkcje transferujące

Chr(x) zwraca znak ASCII. Argumentem jest numer porządkowy

Ord(x) zwraca numer porządkowy. Argumentem jest znak

Round(x) zaokrąglenie

Trunc(x) obcina po przecinku

Najczęściej stosowane typy w Turbo Pascalu

typy całkowitoliczbowe

integer -32768...32767 (4B)

shortint -128...127 (2B)

longint -2147483648...2147483647 (4B)

byte 0...255 (1B)

word 0...65535 (2B)

typ logiczny

boolean true/false

typ znakowy

char przyjmuje kody ASCII

typ wyliczeniowy

polega na wyliczeniu wszystkich jego elementów. Nie można na nim wykonywać działań matematycznych.

Type kolory=(czarny, zielony, niebieski)

Var tło: kolory;

Typy rzeczywiste

Real (8B) 2.9 * 10 ^-39 ... 1.7 * 10 ³⁸

Single (4B) 1,5 * 10 ^-45 ... 3,4 * 10 ³⁸

Double (8B) 5,0 * 10 ^-324 ... 1,7 * 10 ³⁰⁸

Extender (10B) 3,4 * 10 ^-4932 ... 1,1 * 10 ⁴⁹³²

Comp (8B) -2 ⁶³ + 1 ... 2 ⁶³ -1

Instrukcja warunkowa IF - postać I

Instrukcja warunkowa IF ma postać:

IF Warunek THEN

{ Blok instrukcji 1 }

Jeżeli Warunek jest spełniony (prawdziwy) wykonywany jest Blok instrukcji 1, a po nim Blok instrukcji 2; przy warunku niespełnionym wykonywany jest Blok instrukcji 2 (Blok instrukcji 1 zostaje pominięty).

Blok instrukcji 2 nie zależy od spełnienia Warunku - są to instrukcje bezwarunkowe.

Instrukcja warunkowa IF - postać II

Instrukcja warunkowa IF ma postać :

IF Warunek THEN

{ Blok instrukcji 1 }

ELSE

{ Blok instrukcji 2 }

Jeżeli Warunek jest spełniony (prawdziwy) wykonywany jest Blok instrukcji 1, w przeciwnym razie wykonywany jest Blok instrukcji 2. W obu wzajemnie wykluczających się przypadkach zostanie wykonany Blok instrukcji 3.

Blok instrukcji 3 nie zależy od spełnienia Warunku - są to instrukcje bezwarunkowe.

Przypadek funkcji zagnieżdżonych:

If warunek1 then

If warunek2 then

If warunek3 then

Writeln(`trzy warunki są spełnione')

Else

Writeln(`dwa pierwsze warunki są spełnione')

Else

Writeln(`warunek pierwszy jest spełniony')

Funkcja ma wykonać więcej niż jedną instrukcję po Then

If warunek then

Begin

Instrukcje;

Instrukcje;

Instrukcje;

End;

Składnia rozbudowana instrukcji IF

If warunek then

Begin

Instrukcje;

Instrukcje;

End

Else

Begin

Instrukcje;

Instrukcje;

End;

1. Program wypisze większą z dwóch podanych liczb.

Program Instrukcja_IF_1;

{ Program wypisuje większą z dwóch podanych liczb. }

uses

Crt;

var

A, B : Integer; { Deklaracja zmiennych: A- pierwsza liczba; B- druga liczba}

begin

ClrScr; { Procedura czyszczenia ekranu.}

Writeln;

Writeln (' Program wypisuje większą z dwóch podanych liczb.');

Writeln;

Write (' Podaj A: ');

Readln (A); { Wczytanie pierwszej liczby.}

Write (' Podaj B: ');

Readln (B); { Wczytanie drugiej liczby. }

Writeln;

if (A>B) then { Jeśli A>B wykonaj }

Writeln (' Większa jest liczba : ', A)

else { w przeciwnym razie }

Writeln (' Większa jest liczba : ', B);

Writeln; Writeln; Writeln;

Write(' Naciśnij klawisz ENTER...');

Readln;

end.

2. Program obliczy i wyświetli pierwiastki równania kwadratowego .

Program Instrukcja_IF_2;

{ Program oblicza pierwiastki równania kwadratowego. }

uses Crt;

var

A, B, C : Real; { Deklaracja zmiennych }

Delta, X1, X2 : Real;

begin

ClrScr; { Procedura czyszczenia ekranu.}

Writeln;

Writeln(' Program oblicza pierwiastki równania kwadratowego.');

Writeln;

Writeln (' Podaj współczynniki równania kwadratowego.');

Write (' Podaj A: '); { Wczytanie pierwszego współczynnika. }

Readln (A);

Write (' Podaj B: ');

Readln (B); { Wczytanie drugiego współczynnika. }

Write (' Podaj C: ');

Readln (C); { Wczytanie trzeciego współczynnika. }

Writeln;

Delta := Sqr(B)-4*A*C;

if (Delta<0) then { Jeśli Delta<0 wykonaj }

Writeln (' Równanie nie ma pierwiastków rzeczywistych !')

else { w przeciwnym razie }

if (Delta=0) then { Jeśli Delta=0 wykonaj }

begin

X1 := -B/(2*A);

Writeln (' Równanie ma jeden pierwiastek rzeczywisty : ',

'X1=', X1:8:2);

end

else { w przeciwnym razie }

begin

X1 := (-B-Sqrt(Delta))/(2*A);

X2 := (-B+Sqrt(Delta))/(2*A);

Writeln ('Równanie ma dwa pierwiastki rzeczywiste : ','X1=',X1:8:2,';

end; X2=', X2:8:2);

Writeln; Writeln; Writeln;

Write(' Naciśnij klawisz ENTER...');

Readln;

end.

Instrukcja iteracyjna FOR - postać I

Instrukcję FOR stosujemy gdy z góry znamy liczbę powtórzeń w cyklu pętli, jest ona kontrolowana tzw. licznikiem. Jej postać to:

FOR I := Początek TO Koniec DO { Blok instrukcji }

Wartość początkowa - Początek i wartość końcowa - Koniec mogą być dowolnymi wyrażeniami typu porządkowego. W instrukcji pętli stosuje się słowo kluczowe TO - pętla ”w górę”, krok +1.

Instrukcja iteracyjna FOR - postać I

OPIS DZIAŁANIA

Na schemacie zmienna sterująca I spełnia rolę licznika, który steruje cyklami pętli. Zanim instrukcja I := I + 1 będzie wykonana po raz pierwszy, zachodzą następujące zdarzenia :

1. Zmiennej sterującej I zostaje przypisana wartość początkowa Początek.

2. Zostaje wyznaczona wartość końcowa Koniec (jeżeli jest wyrażeniem) i porównana z wartością początkową I. Jeżeli I <= Koniec, to nastąpi wejście do pętli; jeżeli I > Koniec to pętla jest pomijana. Program przechodzi do wykonywania kolejnych instrukcji.

3. Zostaje zapamiętana wartość końcowa Koniec, dzięki czemu może być porównywana z wartością zmiennej sterującej I przed rozpoczęciem każdego następnego cyklu pętli. Ponieważ kolejne wartości zmiennej sterującej są wyznaczane za pomocą funkcji standardowej Succ(I), zatem zmienna sterująca I musi być typu porządkowego (Integer, Char, Boolean).

Instrukcja iteracyjna FOR - postać II

Instrukcję FOR stosujemy gdy z góry znamy liczbę powtórzeń w cyklu pętli, jest ona kontrolowana tzw. licznikiem. Jej postać to:

FOR I := Początek DOWNTO Koniec DO

{ Blok instrukcji }

Wartość początkowa - Początek i wartość końcowa - Koniec mogą być dowolnymi wyrażeniami typu porządkowego. W instrukcji pętli stosuje się słowo kluczowe DOWNTO - pętla ”w dół”, krok -1 .

Instrukcja iteracyjna FOR - postać II

OPIS DZIAŁANIA

Na schemacie zmienna sterująca I spełnia rolę licznika, który steruje cyklami pętli. Zanim instrukcja I := I - 1 będzie wykonana po raz pierwszy, zachodzą następujące zdarzenia :

1. Zmiennej sterującej I zostaje przypisana wartość początkowa Początek.

2. Zostaje wyznaczona wartość końcowa Koniec (jeżeli jest wyrażeniem) i porównana z wartością początkową I. Jeżeli I >= Koniec, to nastąpi wejście do pętli; jeżeli I < Koniec to pętla jest pomijana. Program przechodzi do wykonywania kolejnych instrukcji.

3. Zostaje zapamiętana wartość końcowa Koniec, dzięki czemu może być porównywana z wartością zmiennej sterującej I przed rozpoczęciem każdego następnego cyklu pętli. Ponieważ kolejne wartości zmiennej sterującej są wyznaczane za pomocą funkcji standardowej Pred(I), zatem zmienna sterująca I musi być typu porządkowego (Integer, Char, Boolean).

1. Program wypisze liczby od 1 do 10, a następnie od 10 do 1.

Program Petla_FOR_1;

{ Program wpisuje liczby od 1 do 10, a następnie od 10 do 1.}

uses

Crt;

var

I : Byte; { Deklaracja zmiennej }

begin

ClrScr; { Procedura czyszczenia ekranu. }

Writeln; { Przejście do kolejnego wiersza.}

Writeln (' Program wpisuje liczby od 1 do 10, a następnie od 10 do 1.');

Writeln;

for I := 1 to 10 do { Początek pętli FOR, gdzie I to zmienna sterująca; }

{ wartość początkowa I=1; wartość końcowa I=10; krok=1.}

Write (I, ' '); { Wypisywanie kolejnych liczb od 1 do 10.}

Writeln;

for I:= 10 downto 1 do {Początek pętli FOR, gdzie I to zmienna sterująca;}

{ wartość początkowa I=10; wartość końcowa I=1; krok=1.}

Write (I, ' '); { Wypisywanie kolejnych liczb od 10 do 1}

Writeln; Writeln; Writeln;

Write(' Naciśnij klawisz ENTER...');

Readln;

end.

Instrukcja iteracyjna REPEAT

Instrukcja REPEAT jest pętlą warunkową ze sprawdzeniem warunku na końcu (zatem zawsze będzie wykonany co najmniej jeden cykl pętli ) i ma postać :

REPEAT

Blok instrukcji 1; Blok instrukcji 2; ... Blok instrukcji N;

UNTIL Warunek;

Spełnienie warunku powoduje przerwanie pętli.

1. Program będzie wypisywał podany przez użytkownika tekst tak długo, dopóki nie zostanie wciśnięty dowolny klawisz.

Program Instrukcja_REPEAT_1;

{ Program wypisuje podany przez użytkownika tekst tak długo, }

{ dopóki nie zostanie wciśnięty dowolny klawisz. }

uses

Crt;

var

Tekst : String; { Deklaracja zmiennej Tekst- do wczytania tekstu }

begin

ClrScr; { Procedura czyszczenia ekranu }

Writeln;

Writeln (' Program wypisuje podany przez użytkownika tekst tak długo,');

Writeln (' dopóki nie zostanie wciśnięty dowolny klawisz. ');

Writeln;

Write(' Wpisz tekst, który będę powtarzał : ');

Read(Tekst); { Wczytanie podanego tekstu }

repeat { Początek pętli REPEAT }

Write(Tekst,' '); { Wypisywanie tekstu }

Delay(100); { Procedura przerywająca działanie programu na 100

Milisekund }

until Keypressed; { Koniec pętli REPEAT gdy zostanie wciśnięty dowolny

klawisz }

end.

2. Program czyta kolejne liczby i liczy ich sumę, aż do wpisania 0.

Program Instrukcja_REPEAT_2;

{ Program czyta kolejne liczby i liczy ich sumę, }

{ aż do wpisania przez użytkownika liczby 0. }

uses

Crt;

var

Liczba,Suma: Real; { Deklaracja zmiennych: Liczba- do wczytania podanej }

{ liczby; Suma- do policzenia sumy wpisanych liczb }

begin

ClrScr; { Procedura czyszczenia ekranu }

Writeln;

Writeln (' Program czyta kolejne liczby i liczy ich sumę, ');

Writeln (' aż do wpisania przez użytkownika liczby 0.');

Writeln;

Suma := 0; { Nadanie wartości początkowej zmiennej Suma }

repeat { Początek pętli REPEAT }

Writeln (' Dotychczasowa suma: ', Suma:10:2, '.');

Write (' Podaj liczbę: ');

Readln (Liczba); { Wczytywanie liczby}

Suma := Suma + Liczba { Sumowanie wprowadzanych liczb }

until (Liczba = 0); { Koniec pętli REPEAT }

Writeln;

Writeln (' Całkowita suma: ', Suma:10:2);

Writeln; Writeln;

Write(' Naciśnij klawisz ENTER...');

Readln;

end.

Instrukcja iteracyjna WHILE

Instrukcja WHILE jest pętlą warunkową ze sprawdzeniem warunku na początku i ma postać :

WHILE Warunek DO

{ Blok instrukcji }

Spełnienie warunku powoduje wykonanie pętli.

Instrukcję WHILE odczytujemy następująco :

dopóki Warunek (wyrażenie logiczne) jest prawdziwy (True), wykonuj Blok instrukcji; w przeciwnym przypadku (False) przejdź do dalszej części programu (następnych instrukcji).

1. Program wczytuje znaki z klawiatury tak długo, dopóki nie zostanie wpisany znak (`*') .

Program Instrukcja_WHILE_1;

{ Program wczytuje znaki z klawiatury tak długo, }

{ dopóki nie zostanie wpisany znak ('*'). }

uses

Crt;

var

Znak : Char; { Deklaracja zmiennej Znak }

begin

ClrScr; { Procedura czyszczenia ekranu }

Writeln;

Writeln (' Program wczytuje znaki z klawiatury tak długo,');

Writeln (' dopóki nie zostanie wpisany znak (*). ');

Writeln;

Write(' Podaj znak i wciśnij ENTER : ');

Readln(Znak); { Wczytanie podanego znaku }

while (Znak<>'*') do

begin { Początek pętli WHILE }

Write(' Podaj znak i wci˜nij ENTER : '); { Wyświetlenie komunikatu }

Readln(Znak); { Wczytanie podanego znaku }

end; { Koniec pętli WHILE }

end.

2. Program znajdzie największy wspólny dzielnik dwóch liczb.

Program Petla_WHILE_2;

{ Program znajduje największy wspólny dzielnik dwóch liczb: A i B. }

uses

Crt;

var

A, B, Pom : Integer; { Deklaracja zmiennych }

begin

ClrScr;

Writeln;

Writeln (' Program znajduje największy wspólny dzielnik dwóch liczb: A i B.');

Writeln;

Write (' Podaj A: ');

Readln (A); { Wczytanie pierwszej liczby.}

Write (' Podaj B: ');

Readln (B); { Wczytanie drugiej liczby. }

Writeln;

Write (' NWD podanych liczb (', A, ', ', B, ') = ');

while (A<>B) do

begin { Początek pętli WHILE }

if A<B then { Jeśli A<B to wykonaj }

begin { Początek instrukcji IF }

Pom := A;

A := B;

B := Pom;

end; { Koniec instrukcji IF }

A := A - B;

end; { Koniec pętli WHILE }

Writeln (A);

Writeln;

Write(' Naciśnij klawisz ENTER...');

Readln;

end.

3. Program obliczy sumę N=10 liczb typu Integer.

Program Petla_WHILE_3;

{ Program oblicza sumę N=10 liczb typy Integer. }

uses

Crt;

const

N = 10; { Deklaracja stałej N=10 }

var

K, Suma, X : Integer; { Deklaracja zmiennych: K- do liczenia ilości }

{ wprowadzanych liczb; Suma- do policzenia sumy }

{ wprowadzonych liczb; X- do wczytywania wprowadzanych liczb }

begin

ClrScr;

Writeln;

Writeln (' Program oblicza sumę N=10 liczb typy Integer.');

Writeln (' Wykonanie programu kończy się po wprowadzeniu 10 liczb.');

Writeln;

K := 1; { Nadanie wartości początkowej zmiennej K }

Suma := 0; { Nadanie wartości początkowej zmiennej Suma }

while K<=N do { dopóki K<=N (10) to wykonuj }

begin { Początek pętli WHILE }

Write (' Wprowadź liczbę typu Integer : ');

Read(X); { Wczytanie wprowadzonej liczby }

Writeln;

Suma := Suma + X; { Sumowanie wprowadzanych liczb.}

Writeln (' Suma częściowa liczb wynosi :',Suma:6);

K := K +1; { Zwiększanie wartości K o 1 }

If (K>N) then { Jeśli K>N to wykonaj }

begin

ClrScr;

Writeln; Writeln;

Writeln(' Suma całkowita N=',N,' liczb wynosi :',Suma:6);

Writeln; Writeln;

Writeln(' Naciśnij klawisz ENTER...');

Readkey; { Czytaj klawisz }

end;

end; { Koniec Pętli WHILE }

end.

Instrukcja wyboru CASE - postać I

Instrukcja CASE jest instrukcją wyboru (selekcji), sterującą wyborem jednej z instrukcji do wykonania i ma postać :

CASE Wyrażenie OF

wartość1 : { Blok instrukcji } ;

wartość2 : { Blok instrukcji } ;

. . .

wartośćN : { Blok instrukcji } ;

END;

Instrukcja wyboru CASE - postać II

Instrukcja CASE jest instrukcją wyboru (selekcji), sterującą wyborem jednej z instrukcji do wykonania i ma postać :

CASE Wyrażenie OF

wartość1 : { Blok instrukcji } ;

wartość2 : { Blok instrukcji } ;

. . .

wartośćN : { Blok instrukcji } ;

ELSE

{ Blok instrukcji }

END;

1. Program po wczytaniu numeru (1-3) wypisze odpowiedni komunikat.

Program Instrukcja_CASE_1;

{ Program wczytuje numer (1-3) i wypisuje odpowiedni komunikat }

{ znajdujący się pod wczytanym numerem. }

uses

Crt;

var

Numer : Char; { Deklaracja zmiennej Numer typu znakowego }

begin

ClrScr; { Procedura czyszczenia ekranu }

Writeln;

Writeln (' Program wczytuje numer (1-3) i wypisuje odpowiedni komunikat');

Writeln (' znajdujący się pod wczytanym numerem.');

Writeln;

Writeln (' 1) Poziom łatwy. ');

Writeln (' 2) Poziom średni.');

Writeln (' 3) Poziom trudny.');

Writeln;

Write (' Podaj numer (1-3) i naciśnij ENTER : ');

Read (Numer); { Wczytanie podanego numeru }

Writeln;

case Numer of { Początek instrukcji CASE }

'1':begin

Write(' WYBRAŁEŚ POZIOM ŁATWY !!!');

end;

'2':begin

Write(' WYBRAŁEŚ POZIOM ŚREDNI !!!');

end;

'3':begin

Write(' WYBRAŁEŚ POZIOM TRUDNY !!!');

end;

end; { Koniec instrukcji CASE }

Readln;

Writeln; Writeln; Writeln;

Write(' Naciśnij klawisz ENTER...');

Readln;

end.

2. Program po podaniu cyfry przez użytkownika wypisz jej nazwę słownie.

Program Instrukcja_CASE_2;

{ Program po podaniu cyfry przez użytkownika wypisuje jej nazwę słownie. }

uses

Crt;

var

Cyfra : Byte; { Deklaracja zmiennych: Cyfra- do wczytania cyfry;}

NazwaCyfry : String; { NazwaCyfry- do wypisania słownie cyfry }

begin

ClrScr; { Procedura czyszczenia ekranu }

Writeln;

Writeln (' Program po podaniu cyfry przez użytkownika wypisuje jej nazwę

słownie. ');

Writeln;

Write (' Podaj cyfrę w postaci numeru: ');

Readln (Cyfra); { Wczytanie cyfry }

Writeln;

case Cyfra of { Początek instrukcji CASE }

0 : NazwaCyfry := 'ZERO';

1 : NazwaCyfry := 'JEDEN';

2 : NazwaCyfry := 'DWA';

3 : NazwaCyfry := 'TRZY';

4 : NazwaCyfry := 'CZTERY';

5 : NazwaCyfry := 'PIĘĆ';

6 : NazwaCyfry := 'SZEŚĆ';

7 : NazwaCyfry := 'SIEDEM';

8 : NazwaCyfry := 'OSIEM';

9 : NazwaCyfry := 'DZIEWIĘĆ';

else

NazwaCyfry := 'to nie jest cyfra tylko liczba !!!';

end; { Koniec instrukcji CASE }

Writeln (' Podana cyfra ',(Cyfra),' - ', NazwaCyfry,' !');

Writeln; Writeln;

Writeln(' Naciśnij klawisz ENTER...');

Readln;

end.

3. Program pokazujący działanie prostego menu.

Program Instrukcja_CASE_3;

{ Prosty kalkulator. Program wczytuje dwie liczby, a następnie wyświetla }

{ menu. Z menu można wybrać numer opcji (1-4), pod którym wykona się }

{ odpowiednie działanie matematyczne dla wprowadzonych liczb. }

uses

Crt;

var

Numer : Integer;

Liczba1, Liczba2 : Real;

begin

ClrScr; { Procedura czyszczenia ekranu }

Writeln;

Writeln (' Prosty kalkulator. Program wczytuje dwie liczby, a następnie

wyświetla');

Writeln (' menu. Z menu można wybrać numer opcji (1-4), pod którym

wykona się');

Writeln('odpowiednie działanie matematyczne dla wprowadzonych liczb.');

Writeln;

Write(' Podaj pierwszą liczbę :');

Read(Liczba1); { Wczytanie pierwszej liczby }

Write(' Podaj drugą liczbę :');

Read(Liczba2); { Wczytanie drugiej liczby }

ClrScr;

Writeln;

{--------------------------MENU------------------------}

Writeln(' 1) DODAWANIE.');

Writeln(' 2) ODEJMOWANIE.');

Writeln(' 3) MNOŻENIE.');

Writeln(' 4) DZIELENIE.');

{--------------------------MENU------------------------}

Writeln;

Write(' Podaj numer: ');

Read(Numer); { Wczytanie numeru opcji menu }

ClrScr;

case Numer of { Początek instrukcji CASE }

1:begin

Writeln;

Write(' Suma liczb ',liczba1:3:0,' i ',liczba2:3:0,' wynosi:liczba1+Liczba2:3:0);

end;

2:begin

Writeln;

Write('Różnica liczb',liczba1:3:0,' i ',liczba2:3:0,'wynosi:',Liczba1-liczba2:3:0);

end;

3:begin

Writeln;

Write('Iloczyn liczb ',liczba1:3:0,' i ',liczba2:3:0,'wynosi:',Liczba1*Liczba2:3:0);

end;

4:begin

Writeln;

Write('Iloraz liczb ',liczba1:8:2,' i ',liczba2:8:2,' wynosi :',Liczba1/Liczba2:8:2);

end;

end; { Koniec instrukcji CASE }

Readln;

Writeln; Writeln; Writeln;

Write(' Naciśnij klawisz ENTER...');

Readln;

end.

Dodatek

Typy zmiennych prostych

Zmienne mogą się różnieć w zależności od używanego kompilatora, ale są to zwykle małe, kosmetyczne różnice.

Zmienne liczbowe i ich zakres reprezentacji liczby:
Typy całkowite:
Integer	-32768..32767
LongInt	-2147483648..2147483647
ShortInt	-128..127
Byte	0..255
Word	0..65535
Typy zmiennoprzecinkowe:
Real	2,9e-39..1,7e+38
Single	1,5e-45..3,4e+38
Double	50e-324..1,7e+308
Extended	3,4e-4932..1,1e+4932
Comp	-9,2e-18..9,2e+18
Inne typy zmiennych
Pointer	Jest to zmienna która wskazuje na miejsce w pamięci.
String	Jest to zmienna tekstowa zawierająca łańcuch znaków (max.255).
Char	Jest to zmienna zawierająca jeden znak.

Procedury Write i WriteLn pozwalają na wyprowadzanie liczb w tzw. postaci sformatowanej, z określoną liczbą cyfr przed i po kropce dziesiętnej. Aby to osiągnąć, argumenty procedury Write, WriteLn uzupełnia się o określenie szerokości pól przykładowo: Writeln(Liczba:Szerokość_pola:Liczba_miejsc_dziesiętnych), czyli Write(Pi:2:2); co jest szczególnie przydatne przy używaniu typów zmiennoprzecinkowych.

Operatory logiczne

Operatowami logicznymi w języku Pascal są i, lub i albo czyli AND, OR i XOR. Koniunkcja (AND) jest prawdziwa (czyli ma wartość logiczną TRUE czyli bit o wartości 1) gdy oba elementy nią połączone są prawdziwe - w przeciwnych wypadkach jest fałszywa (wartość logiczna FALSE czyli bit o wartości 0), alternatywa (OR) jest prawdziwa, gdy choć jeden element nią połączony jest prawdziwy, różnica symetryczna (XOR) jest prawdziwa,gdy elementy nią połączone są różnej wartości logicznej. Operatorem zaprzeczenia jest nie czyli NOT, w szególności NOT FALSE = TRUE. Do głębszych rozważań odsyłam do matematycznej logiki dwuwartościowej i zdań logicznych.

Operatory i funkcje matematyczne

Operator	Opis	Przykład
+	dodawanie	2+3
-	odejmowanie	5-3
*	mnożenie	3*4
/	dzielenie	8/2
<	mniejsze	3<6
>	większe	6>4
>=	większe lub równe	5>=5
<=	mniejsze lub równe	j.w.
<>	nierówne	5 <> 8
DIV	dzielenie całkowite	7 DIV 4 = 1
MOD	reszta z dzielenia	7 MOD 4 = 3
ABS(x)	wartość bezwzględna (moduł) liczby x	ABS(-5) = 5
SQR(x)	kwadrat liczby x	SQR(5) = 25
SQRT(x)	pierwiastek kwadratowy z x	SQRT(9) = 3
LN(x)	logarytm naturalny z x	LN(1) = 0
EXP(x)	liczba e do potęgi x	EXP(1) = e
SIN(x)	sinus x	SIN(0) = 0
COS(x)	cosinus x	COS(0) = 1
ARCTAN(x)	arcustangens x	ARCTAN(1)=0.785=PI/4
SUCC(x)	następnik	SUCC(8)=9
PRED(x)	poprzednik	PRED(8)=7
ROUND(x)	zaokrąglenie do najbliższej liczby całkowitej	ROUND(3.4)=3
TRUNC(x)	obcięcie części dziesiętnej liczby	TRUNC(3.7)=3
ODD(x)	funkcja nieparzystości	ODD(4)=False

Podprogramy - procedury i funkcje

Jeśli część kodu wykorzystywać będziemy wielokrotnie - możemy użyć pętli, a jeśli wykorzystywać będziemy wielokrotnie ale w różnych miejscach programu - możemy stworzyć procedurę lub funkcję (w zależności od potrzeb) która będzie fragmentem kodu do powtórzenia. Co zyskujemy w ten sposób? Przede wszystkim przejrzystość strukturalną samego programu, jest on bardziej czytelny, a w przypadku eksportu procedur do osobnych modułów (na tym opera sie obecnie Delphi) możemy używać ich wielokrotnie w różnych programach - zatem stają się one uniwersalne i przeznaczone do wykorzystania w przyszłości.
Jaka jest różnica pomiędzy procedurą a funkcją? Procedura to podprogram - możemy przekazać mu dane do obliczeń, a następnie z procedury powrócić do programu głównego i pracować dalej, ale możemy też wywołać procedurę bez żadnych parametrów - ot, tak, jako część kodu do powtórzenia - w celu wyświetlenia menu programu czy pomocy. Funkcji uzywamy zwykle w celu dokonania jakiś obliczeń - przykładowo sqr() czy sqrt() - ponieważ zwracają one wartość.

procedure nazwa_procedury (lista parametrów);
    deklaracja zmiennych lokalnych;
begin
    instrukcje procedury;
end;

function nazwa_funkcji (parametry):typ_zwracanego_wyniku;
    deklaracja zmiennych lokalnych;
begin
    instrukcje funkcji;
end;

Procedurę definiujemy postaci:	Funkcję definiujemy postaci

Lista parametrów jest sposobem na przekazania danych dla danej funkcji czy procedury, a poszczególne parametry oddziela się średnikami. Zmienne deklarowane w podprogramie są lokalne, to znaczy istnieją tylko na czas działania podprogramu - program główny nie ma do nich dostępu - za to podprogram ma dostęp do zmiennych globalnych - czyli tych zadeklarowanych na początku po słowie var.

By skorzystać z funkcji, podajemy w programie jej wywołanie czyli jej nazwę z odpowiednimi parametrami. Brak opdpowiednich parametrów, lub niedopasowanie ich typów to najczęstsze problemy przy korzystaniu z procedur. Pamiętać należy, że deklaracja parametrów procedury ma postać:
procedure nazwa(nazwa_parametru : typ_parametru ; nazwa:typ; nazwa:typ );
i dokładnie tego samego typu muszą być parametry przy wywołaniu procedury, a w przypadku funkcji także musi się zgadzać typ zwracanego wyniku, bo deklaracja parametrów funkcji ma postać:
function nazwa(nazwa_parametru : typ_parametru ; nazwa:typ; nazwa:typ ):typ_wyniku;
a jej wywołanie jest postaci:
zmienna:= nazwa_funkcji(parametry); {czyli typ wyniku funkcji musi być taki sam jak typ zmiennej}

Mechanizm przekazywania parametrów. ( !! )
Parametr procedury lub funkcji nie poprzedzony słowem kluczowym VAR jest przekazywany przez wartość, czyli procedura lub funkcji nie operuje na danej zmiennej ale otrzymuje jej kopię i wykonane działania na zmiennej są aktualne jedynie w obrębie podprogramu. Po zakończeniu podprogramu zmienna wraca do wartości sprzed wywołania.	Poprzedzenie parametru słowem kluczowym VAR jest przekazywaniem poprzez zmienną, czyli procedura lub funkcja dokonuje trwałych zmian na zmiennej, a jej modyfikacje skutkują także w programie głównym.

Przykładowa bezparametrowa procedura może mieć postać:

program bardzo_wazny; procedure opis_programu; begin writeln('Ten program jest ważny'); writeln('albo jeszcze ważniejszy'); end; begin {początek programu głównego} opis_programu; end. {koniec programu głównego}

ale możemy także zdefiniować procedurę (albo jeszcze lepiej funkcję), np.: dodającą dwie liczby i zwracającą ich sumę.

program funkcjonalne_dodawanie; var a,b,wynik:integer; function suma(a,b: integer): integer; begin suma:=a+b; end; begin writeln('Podaj 1-szą liczbę'); readln(a); writeln('Podaj 2-gą liczbę'); readln(b) wynik:=suma(a,b); writeln('Suma tych liczb to : ',wynik); end.

Na szczególną uwagą zasługuje linijka piąta, jako przypisanie wartości funkcji suma poprzez odwołanie się do jej nazwy.

Przejrzyj przykłady procedur i funkcji umieszczonych w zadaniach: 3.48, 3.50, 3.52

Typy zmiennych złożonych (strukturalnych) - tablice, rekordy

Złożone struktury zmiennych (zwłaszcza rekordy) są wprowadzeniem do programowania obiektowego, które w obecnych czasach jest chyba najbardziej rozwiniętym zagadnieniem programowania.

Tablice zmiennych

Tablice są strukturami złożonymi z ustalonej liczby elementów tego samego typu, który może być zarówno typem prostym, łańcuchowym lub strukturalnym. Elementy tablicy są wskazywane przez indeks lub zespół indeksów. Powstały, ponieważ przechowywanie dużej ilości danych w zadeklarowanych zmiennych byłoby utrudnione - w przypadku gdybyśmy chcieli przechować na przykład listę uczniów szkoły - musimy zadeklarować kilkaset zmiennych. Pomijając naszą fantazję w wymyślaniu nazw, pisanie programu mogłaby się nieco wydłużyć, a sama lista zadeklarowanych zmiennych byłaby olbrzymia. Tablica to ciąg zmiennych, gdzie każda ze zmiennych posiada swój unikalny identyfikator - numer swojej pozycji. Można wyobrazić sobie tablicę, jako dwuwierszową tabelę, której górny wiersz to indeksy pozycji, a dolny to wartości. W szczególności na przykład tablica 255 elementów typu char to string.

Tablicę deklarujemy słowem array w sekcji var. Przykładowo:

program tablica; var moja_tablica : array [1..10] of integer; begin moja_tablica[1]:=12; writeln(moja_tablica[1]); moja_tablica[2]:=2; moja_tablica[3]:=moja_tablica[1]+moja_tablica[2];  end.

zadeklarowana tablica moja_tablica jest ciągiem 10 elementów typu integer, w szczególności słówko of określa nam typ zmiennej, która przechowywana będzie w tablicy, a 1..10 podaje w jaki sposób będzie indeksowana tablica, oraz podaje ilość jej elementów. Odwołanie do konkretnego elementu tablicy następuje poprzez wywołanie go jako indeks w nawiasach kwadratowych. Możemy tworzyć tablice nie tylko liczb, ale i tablice znaków czy stringów. Zadeklarowanie w tej postaci nazwisko 1000 uczniów nie przedstawia już większego problemu.

Ponadto tworzyć możemy tablice wielowymiarowe (na przykład dwuwymiarową macierz w-wierszy na k-kolumn pewnego układu równań, czy też tabelę-szachownicę 8 kolumn na 8 wierszy), w których możemy przechowywać duże ilości informacji. Przykładowo:

program tablica; var moja_tablica : array [1..8,1..8] of integer;  begin moja_tablica[1,2]:=12; end.

tablica zadeklarowana powyżej ma 64 pola - 8 wierszy na 8 kolumn. Możemy tworzyć tablice o dowolnej liczbie wymiarów, a przy okazji deklarowania tablic warto zauważyć, że struktura języka Pascal nie może zajmować więcej niż 2¹⁶ = 65 536 bajtów, a nawet łącznie całość zarezerwowanych komórek pamięci też nie może przekroczyć tego rozmiaru.

Przejrzyj przykłady z użyciem tablic: 4_02,4_03

        Procedurę (PROCEDURE) lub funkcję (FUNCTION) deklarujemy po deklaracji zmiennych (VAR). Są to wyodrębnione części programu, stanowiące pewną całość, posiadające jednoznaczną nazwę i ustalony sposób wymiany informacji z pozostałymi częściami programu. Procedury i funkcje są stosowane do wykonania czynności, które mogą być wykorzystane w różnych programach lub do wykonania czynności wielokrotnie powtarzanych przez dany program. Różnica pomiędzy procedurą a funkcją polega na sposobie przekazywania wartości. Zadaniem procedury jest wykonanie pewnej sekwencji czynności, polegających zwykle na obliczaniu jedej lub wielu wartości. Natomiast zadaniem funkcji jest obliczenie jedej wartości (typu prostego lub wskaźnikowego). Odmienne są też sposoby wywołania procedur i funkcji, np.

 

Definicja procedury:

PROCEDURE Nazwa_Procedury(lista_parametrów);

...Część_opisowa

BEGIN

...Ciąg_instrukcji

END;

W definicji procedury listę parametrów możemy pominąć.

Definicja funkcji:

FUNCTION Nazwa_Funkcji(lista_parametrów): Typ_wyniku;

...Część_opisowa

BEGIN

...Ciąg_instrukcji

END;

 

W obu przypadkach lista parametrów zawiera deklarację parametrów, przy czym poszczególne deklaracje oddziela się średnikami. W przypadku funkcji w ciągu instrukcji musi wystąpić co najmniej jedna instrukcja przypisania w postaci:

 

Nazwa_Funkcji:=Wyrażenie

powodująca przypisanie wartości pod nazwę funkcji, przy czym co najmniej jedna z tych instrukcji musi być wykonana po wywołaniu funkcji. Typ wyniku funkcji jest określony za pomocą identyfikatora typu.

Instrukcje

        Czynności wykonywane na danych są opisywane za pomocą instrukcji. Instrukcjie języka Turbo Pascal dzielą się na instrukcje proste, tj. takie, które nie zawierają jako składowych innych instrukcji, oraz instrukcje strukturalne, zbudowane na podstawie pewnego schematu strukturalizacji kilku instrukcji.

Oto pełen podział instrukcji:

 Instrukcje proste

 Instrukcje przypisania
 Instrukcje skoku
 Instrukcje puste
 Instrukcje wywołania procedury
 Instrukcje inline

 Instrukcje strukturalne

 Instrukcje złożone
 Instrukcje warukowe

 Instrukcje if .. then ("jeśli")
 Instrukcje case .. of (wyboru)

 Instrukcje iteracyjne

 Instrukcje for .. do ("dla")
 Instrukcje while .. do ("dopóki")
 Instrukcje repeat .. until ("powtarzaj")

 Instrukcje wiążące
 Instrukcje asemblerowe

        Co nazywamy instrukcją prostą wytłumaczyłem po krótce już na wstępie. Teraz przypomne tylko na jakie składowe dzielimy te instrukcje. Więc do instrukcji prostych zaliczamy: instrukcje przypisania, instrukcje skoku, instrukcje puste, instrukcje wywołania procedury, instrukcje inline.

        Instrukcja przypisania służy do przypisania zmiennej nowej wartości. Ogólna jej postać jest następująca:

 

Odwołanie_do_zmiennej:=wyrażenie;

lub

Nazwa_funkcji:=wyrażenie;

 

Dla każdego przypisania wartość wyrażenia musi być zgodna w sensie przypisania z typem zmiennej.

Przykłady:

 

a:=1;

tekst:="Kurs Pascala";

x:=x+1

warunek:=a=b;

 

        Instrukcja skoku jest jedyną instrukcją, której stosowanie nie jest zalecane. Jej stosowanie zmniejsza przejrzystość programu, utrudnia jego optymalizację...(można by pisać i pisać...). Instrukcja ta może być zawsze zastąpiona instrukcjami "dopóki" lub "powtarzaj". Ogólna jej postać jest następująca:

 

GOTO etykieta;

 

Powoduje to przekazanie sterowania do instrukcji programu poprzedzonej podaną etykietą.

Przykład:

 

PROGRAM Etykiety;

LABEL et;

...

BEGIN

...

GOTO et;

...

x := a+2;

...

END.

 

        Zapisanie instrukcji pustej nie wymaga użycia żadnego symbolu języka i nie powoduje ona wykonania żadnych czynności. Instrukcję tą stosuje się w tych kontekstach, w których jest wymagane użycie instrukcji, ale chce się uniknąć wykonania jakiejkolwiek czynności, lub w celu ułatwienia opracowania programu.

        Instrukcja wywołania procedury jak sama nazwa wskazuje służy do wywoływania w programie procedur. Ogólna postać wywołania jest następująca:

 

Nazwa_Procedury;

lub

Nazwa_Procedury(lista_parametrów);

 

Przykład:

Jeśli w części opisowej programu zadeklarujemy następującą procedurę:

 

PROCEDURE(X,Y:Byte;Tekst:String[10]);

BEGIN

...

END;

 

To aby tą procedurę wywołać to w części wykonawczej programu piszemy:

 

PROCEDURE(10,10,"Kurs Pascala");

 

        Do dołączania w programie lub module paskalowym krótkich podprogramów lub instrukcji napisanych w kodzie maszynowym (zgroza!) służy dyrektywa i instrukcja inline.. Jej postać jest następująca:

 

INLINE (lista_elementów_inline);

 

Nie będę się więcej rozpisywać na ten temat gdyż instrukcja ta bez znajomości Assemblera jest bezużyteczna - w końcu to kurs dla początkujących, a oni raczej Assemblera nie znają.

Przykład:

 

INLINE ($CD/$12/$89/$46/$04);

 

        Co nazywamy instrukcją strukturalną wytłumaczyłem po krótce już na wstępie. Teraz przypomne tylko na jakie składowe dzielimy te instrukcje. Więc do instrukcji strukturalnych zaliczamy: instrukcje złożone, instrukcje warunkowe, instrukcje iteracyjne, instrukcje wiążące, instrukcje asemblerowe.

        Instrukcja złożona jest ciągiem instrukcji poprzedzonym słowem kluczowym begin i zakończonym słowem kluczowym end. Instrukcje wchodzące w skład instrukcji złożonej wykonywane są sekwencyjnie. Struktura tej instrukcji jest następująca:

 

BEGIN

Instrukcja_1;

Instrukcja_2;

...

Instrukcja_n

END

 

Przykład:

 

BEGIN

a:=1;

b:=a+4;

c:=a-b;

GOTO Franek;

END

 

 Instrukcje warunkowe uzależniają wykonywanie innych instrukcji od spełnienia określonego warunku. W Pascalu istnieją dwie instrukcje warunkowe: instrukcje if .. then ("jeśli"), instrukcje case .. of (wyboru).

        Instrukcja "jeśli" uzależnia wykonywanie innej lub innych instrukcji od spełnienia lub niespełnienia podanego warunku. Ogólna jej postać jest następująca:

 

IF wyrażenie THEN instrukcja

lub

IF wyrażenie THEN instrukcja

ELSE instrukcja

 

Przy czym wartością wyrażenia powinna być wartość logiczna True lub False. Instrukcja występująca po słowie kluczowym then lub else może być dowolną instrukcją prostą lub strukturalną. Jeśli wartością wyspecyfikowanego wyrażenia jest True, to zostanie wykonana instrukcja podana po słowie then. W przeciwnym przypadku wykonana będzie następna instrukcja po instrukcji "jeśli" (gdy brak else) lub instrukcja podana po słowie else.

Przykład:

 

IF X=Y THEN A:=0

ELSE A:=1;

 

 

        W programowaniu często mamy do czynienia z sytuacją, gdy wykonanie różnych operacji jest uzależnione od wartości pewnej zmiennej. Pomocna może się tu okazać instrukcja wyboru, której ogólna postać jest następująca:

 

CASE wyrażenie OF

sekwencja_instrukcji_wyboru

END

lub

CASE wyrażenie OF

sekwencja_instrukcji_wyboru

ELSE instrukcja

END

 

gdzie wartość wyrażenia musi być typu porządkowego. Sekwencja instrukcji wyboru składa się z instrukcji, przy czym każda z nich poprzedzona jest jedną lub kilkoma stałymi, zwanymi stałymi wyboru, które od instrukcji oddzielone są dwukropkiem. Poszczególne stałe wyboru oddzielamy przecinkami.

Przykład:

 

CASE znak OF

'+' : BEGIN

d:=d+1;

z:=z-1;

END;

'-' : BEGIN

d:=d-1;

z:=z+1;

END;

END;

 

        Instrukcje iteracyjne służą do organizowania cykli programowych, tj. wielokrotnego wykonywania pewnych sekwencji instrukcji. W Pascalu istnieją trzy rodzaje instrukcji iteracyjnych: instrukcje for .. do ("dla"), instrukcje while .. do ("dopóki") i instrukcje repeat .. until ("powtarzaj").

 

        Instrukcje "dla" tzw. pętlę stosuje się zwykle w celu wykonania pewnej grupy instrukcji w przypadku, gdy liczba powtórzeń jest znana w danym miejscu programu. Instrukcja ta może mieć jedną z dwu następujących postaci:

 

FOR zmienna:=wyrażenie_1 TO wyrażenie_2 DO intrukcja

lub

FOR zmienna:=wyrażenie_1 DOWNTO wyrażenie_2 DO intrukcja

 

Zmienna, zwana zmienną sterującą, musi być identyfikatorem typu porządkowego i powinna być lokalna w bloku zawierającą daną instrukcję "dla". Wartość wyrażenia 1 i wyrażenia 2 powinna być zgodna w sensie przypisania z typem zmiennej sterującej. Instrukcja występująca po słowie kluczowym DO może być dowolną instrukcją prostą lub strukturalną.

Przykłady:

 

FOR i:=1 TO 10 DO x:=x+i;

 

Instrukcja wykonywana 10-krotnie powoduje zwiększenie zmiennej X o aktualną wartość zmiennej I.

 

FOR j:=10 DOWNTO 1 DO x:=x+j;

 

Instrukcja wykonywana 10-krotnie (od "tyłu" :-)) powoduje zwiększenie zmiennej X o aktualną wartość zmiennej J.

  Instrukcja "dopóki" służy do opisywania interacji ze sprawdzeniem warunku na początku i ma postać:

 

WHILE wyrażenie DO intrukcja

 

Wyrażenie, które najczęściej jest wyrażeniem porównania, powinno w wyniku dawać wartość logiczną (True lub False), a instrukcja występująca po słowie do może być dowolną instrukcją prostę lub strukturalną. Instrukcja ta wykonywana jest tak długo jak długo wartością wyrażenia jest True.

Przykład:

 

k:=1;

WHILE k<10 DO BEGIN

x:=x*x;

k:=INC(k) {INC(k) działa jak k:=k+1;};

END;

 

        Instrukcja "powtarzaj" służy do opisywania interacji ze sprawdzeniem warunku na końcu i ma postać:

 

REPEAT

Instrukcja_1

Instrukcja_2

...

Instrukcja_n

UNTIL wyrażenie

 

Wyrażenie powinno dawać w wyniku wartość logiczną, a każda z instrukcji może być dowolną instrukcją prostą lub strukturalną. Instrukcje wewnętrzne są wykonywane conajmniej jeden raz, a zakończenie przetwarzania instrukcji "powtarzaj" następuje, gdy wartością wyrażenia występującego po słowie kluczowym until jest True.

Przykład:

 

i:=1;

REPEAT

Writeln('Linia ',i);

i:=i+1;

UNTIL i=10;

 

        Do odwołania się do poszczegolnych pol rekordu lub obiektu służą desygnatory pól, składające się z indentyfikatora odpowiedniego pola i nazwy zmiennej rekordowej lub obiektowej. Zastosowanie instrukcji wiążącej pozwala na wygodniejsze odwołanie się do wspomnianych pól, a także zwiększa czytelność programu. Jej postać jest następująca:

 

WITH lista_zmiennychDO instrukcja

 

przy czym lista zmiennych zawira oddzoelone przecinkami identyfikatory zmiennych rekordowych lub obiektowych, a instrukcja po słowie kluczowym do może być dowolną instrukcją prostą lub strukturalną. Umieszczenie zmiennej rekordowej lub obiektowej po słowie kluczowym with pozwala wewnątrz instrukcji wiążącej na odwołanie się do pól tej zmiennej za pomocą samych identyfikatorów pól. Identyfikatory te traktowane są w instrukcji wewnętrznej jako zmienne.

Przykład:

 

Załóżmy następującą deklarację:

VAR comp: RECORD

re,im: Real;

END;

Przypisanie do tego rekordu w instrukcji wiążącej

jest następujące:

WITH comp DO

BEGIN

re:=1;

im:=1;

END;

Jest to równoważne z takim przypisaniem w instrukcji

złożonej:

BEGIN

comp.re:=1;

comp.im:=1;

END;

...

instrukcja_asemblera_n

END;

Definiowanie własnych typów

Typ wyliczeniowy

Type

TPlec=(kobieta,mezczyzna);

TDniTygodnia=(pon,wt,Sr,czw,Pt,sob,niedz);

TMiesiace=(Sty,lut,mar,……);

Var

Plec:TPlec;

Biezacymiesiac:TMiesiac;

TemperaturyTygodniowe:array[TDniTygodnia] of Integer;

ZarobkiWciagiRoku:array[Tmiesiace] of Real;

Odwołania

Plec:=mezczyzna;

BiezacyMiesiac:=grudzien;

TemperaturyTygodniowe[pon]:=6;

ZarobkiWciaguRoku[Biezacymiesiac]:=1200;

Standardowo w Turbo Pascalu masz do dyspozycji następujące

moduły:

Crt moduł ułatwiający obsługę ekranu, klawiatury, dźwięku (tylko wbudowanego głośnika), kolorów, okien;

DOS moduł z procedurami systemowymi; Graph moduł do obsługi grafiki w Turbo Pascalu;

Graph moduł zawierający funkcje i procedury graficzne z Turbo Pascala 3, stworzony w celu umożliwienia uruchamiania programów napisanych w tej wersji kompilatora;

Overlay moduł to tworzenia programów z nakładkami;

Printer moduł do obsługi drukarki;

System moduł z procedurami standardowymi (niektóre już znasz);

Strings moduł pozwalający operować na długich łańcuchach (tylko w TP7);

Turbo3 moduł zawierający funkcje i procedury nie związane z grafiką z Turbo Pascala 3, stworzony w celu umożliwienia uruchamiania programów napisanych w tej wersji kompilatora;

WinDos moduł rozszerzający działanie modułu Dos o możliwość posługiwania się długimi łańcuchami (tylko w TP7);

Zajmijmy się modułem Crt. Oto kilka funkcji, które mogą okazać się przydatne:

ClrSCr; Procedura czyszczenia ekranu, znacznie bardziej efektywna, niż te, które pisaliśmy do tej pory, po jej wykonaniu kursor znajdzie się w pierwszym wierszu ekranu.

Delay (MS: Word) Procedura przerywa działanie programu na MS milisekund. Mógłbyś sam napisać taką procedurę, wykorzystującą odpowiednio długą pętlę, wykonującąjakieś skomplikowane polecenie. Po co jednak wyważać otwarte drzwi?

DelLine Procedura czyści zawartość wiersza, w której znajduje się kursor.

Procedura przenosi kursor do znaku o współrzędnych X i Y, nie naruszając zawartości ekranu.

GotoXY(X.V:Byte)

KeyPressed:Boolean

Funkcja zwraca wartość True, gdy w buforze klawiatury (klawisze wciśnięte na klawiaturze są bowiem buforowane, czyli pamiętane nawet wtedy, gdy program nie wykonuje instrukcji czytania klawiatury, tylko robi coś innego) znajdują się jakieś wciśnięte klawisze, a False w przeciwnym razie. Aby usunąć znak z buforu należy go przeczytać - na przykład funkcjąReadKey lub standardowymi instrukcjami czytania.

NoSound

ReadKey:Char

Sound(Hz:Word)

TextBackground (Color: Byle)

TextColor(Color:Byte)

WhereX:Byte;

WhereY:Byte;

Procedura powodująca zakończenie wydawania dźwięku przez głośnik komputera (aby uzyskać dźwięk, skorzytsaj z procedury Sound).

Funkcja, zwracająca kod pierwszego klawisza z bufora klawiatury.

Procedura rozpoczynająca emitowanie przez głośnik kom­putera dźwięku o częstotliwości Hz herców. Aby zakończyć należy wywołać funkcję NoSound;

Procedura, ustalająca kolor tła dla wypisywanego tekstu.

Procedura, ustalająca kolor znaków dla wypisywanego tekstu.

Funkcja, określająca kolumnę, w której znajduje się kursor.

Funkcja, określająca wiersz, w której znajduje się kursor.

kursor.

Można także, zamiast deklarować kolory numerycznie, wykorzystać zdefiniowane w module state (w nawiasie podana jest polska nazwa koloru i wartość liczbowa stałej): Black (czarny; 0), Blue (niebieski; 1), Grcen (zielony, 2), Cyan Icyjan, 3), Red (czerwony, 4), M a gen t a (karma-zynowy, 5), Brown (brązowy, 6), LightGray (jasnoszary, 7), DarkGray (ciemnoszary. 8), Li-gtitBIue (jasnoniebieski, 9), LightGreen (jasnozielony, 10), LightCyan (jasny cyjan, 11), Li-ghtRcd (jasnoczerwony, 12), Li gh t Ma gen ta (jasnokarmazynowy, 13), Yellow (żółty, 14), White (biały, 15). Pamiętaj, że dla tlą dopuszczalne są tylko zmienne z zakresu 0..7.

Obsługa plików

Definicja zmiennej typu plikowego może mieć jedną z poniższych form:

var

PlikTekstowy : Text;

PlikJakiegosTypu : f ile of TypElernentow;

PlikBezTypu : file;

Typ elementów pliku może być dowolny: liczbowy, wyliczeniowy, tablicowy, rekordowy.

Najprostszym typem plików są pliki tekstowe. Pamiętany w nich tekst można wczytywać w podobny sposób, jak byłby wpisywany przez użytkownika na klawiaturze. Zapisywanie do takiego pliku nie różni się specjalnie od wypisywania tekstu na ekran.

Przed wykonaniem jakiejkolwiek operacji na pliku, musimy dokonać przypisania nazwy pliku zmiennej plikowej. Dokonuje się tego procedurą:

Assign (ZmiennaPlikowa, Nazwa);

Następnie należy otworzyć jednym z poleceń:

Reset (ZmiennaPlikowa); Rewrite (ZmiennaPlikowa);

W przypadku pliku tekstowego Reset otwiera istniejący plik na dysku i pozwala wyłącznie na czytanie z niego. Rewrite tworzy nowy plik (a jeżeli j nazwie był na dysku kasuje jego zawartość) i pozwala jedynie na zapisanie tekstu.

Jeżeli mamy do czynienia z plikiem elementów określonego typu, Reset otwiera istniejący plik i pozwala zarówno na czytanie jak i na pisanie w naszym bieżącym bieżącym położeniu w pliku( na początku znajdujemy się przed pierwszym elementem po przeczytaniu lub zapisaniu dowolnego zawsze przesuwamy się o jedną pozycję do przodu). Rewrite zaś tworzy nowy plik lub kasuje już istniejący, pozwalając także na zapisywanie i czytanie elementów z bieżącego położenia w pliku.

Dla plików tekstowych istnieje trzecia metoda otwarcia:

Append (ZmiennaPlikowa);

Procedura ta otwiera plik tekstowy w trybie dopisywania na jego końcu.

Pojęcie bieżącego położenia w pliku jest niezwykle istotne.

W przeciwieństwie do tablic w których mieliśmy dostęp do dowolnej komórki, podając jej indeks.

W przypadku plików tekstowych możemy jedynie przesuwać się „w przód" pliku, odczytując kolejne elementy.

W przypadku plików typu nie-tekstowego możemy przesuwać się w przód pliku bądź do tyłu, ale w dalszym ciągu nie ma możliwości podania, w którym miejscu należy coś zapisać lub odczytać.

Po zakończeniu działania z plikiem należy go zamknąć poleceniem:

Close (ZmiennaPlikowa);

Do dyspozycji mamy jeszcze bardzo przydatne funkcje i procedury. Dla plików tekstowych przeznaczonajest funkcja:

Eoln (ZmiennaPlikowa): Boolean;

Zwraca ona wartość True, jeżeli znajdujemy się na końcu wiersza i False w przeciwnym razie. Dla plików tekstowych i nietekstowych bardzo pomocna jest funkcja:

Eof (ZmiennaPlikowa): Boolean;

Przyjmuje wartość prawdziwą, jeżeli znajdujemy się na końcu pliku, a False -jeżeli nie.

Dla plików typu file of Typ do dyspozycji mamy funkcje:

FilePos (ZmiennaPlikowa): Longint;

która określa, na której pozycji w pliku się znajdujemy (czyli, ile elementów pliku jest już ,,za nami") oraz:

FileSize (ZmiennaPlikowa)

Longint;

Oblicza ona rozmiar pliku (czyli ile elementów danego typu zawiera). Dostępna jest także procedura:

Seek (Zmienna, Pozycja);

Przesuwa nas ona do określonego miejsca w pliku. Używając procedury Seek oraz funkcji FilePos, należy pamiętać, że elementy pliku są numerowane od 0. Aby więc ustawić się przed pierwszym elementem (a więc na początku pliku), należy użyć procedury: Seek [F, O). Aby udać się do ostatniego elementu pliku - Seek [F, FileSize[F]-1). FilePos(F) = 1 oznacza, że kolejnym przeczytanym elementem będzie drugi element pliku.

W celu odczytania elementów z pliku używamy znanych nam już instrukcji:

Read (ZmiennaPlikowa, Element); Readln (ZmiennaPlikowa, Element);

Pierwsza z nich ma zastosowanie dla dowolnego pliku. Czyta z niego pojedynczy element. Drugiej używa się jedynie w plikach tekstowych. Po przeczytaniu elementu instrukcja po­woduje przejście do kolejnego wiersza tekstu.

Bardzo podobnie odbywa się zapis do pliku. Do dyspozycji mamy instrukcje:

Write (ZmiennaPlikowa, Element); Writeln (ZmiennaPlikowa, Element);

Pierwsza powoduje zapisanie elementu w pliku dowolnego typu. Druga ma zastosowanie tylko dla plików tekstowych. Powoduje zapisanie elementu i przejście do nowego wiersza.

Wskaźniki

Wskaźniki pozwalają powoływać zmienne do _; życia dopiero w chwili, kiedy są potrzebne i uwalniać od nich program (i pamięć komputera) zaraz po tym, jak staną się niepotrzebne. Nazwano je zmiennymi dynamicznymi.

Zmienna o określonej przez nas nazwie nie określa wartości zmiennej, a jedynie adres pamięci, pod którym zmienna jest ukryta.

Deklaracja typu wskaźnikowego i zmiennej wskaźnikowej ma postać:

type

TWskaznik = ^TypZmiennej;

var

Wskaźnik : TWskaznik;

Przed użyciem należy każdej zmiennej przydzielić miejsce w pamięci procedurą

New (ZmiennaWskaznikowa);

Po jej wykonaniu zostanie zarezerwowany odpowiedni obszar w pamięci na przechowywa­nie danych, a ZmiennaWskaznikowa będzie pamiętała jego adres. Odwołanie do wartości zmiennej następuje poprzez ZmiennaWskaznikowa^. Dzięki dodaniu strzałki na końcu po­kazuje nam już nie adres pamięci, lecz wartość „wyciągniętą" spod tego adresu.

Po zakończeniu używania zmiennej dobrze jest ją „uśmiercić" - zwolnić zajmowany przez nią obszar pamięci i usunąć wskaźnik. Odbywa się to poprzez wywołanie procedury:

Dispose (ZmiennaWskaznikowa);

Często chcielibyśmy w programie wiedzieć, czy zmienna wskaźnikowa wskazuje na jakąś zmienną w pamięci, czy też nie. Na potrzeby takiego sprawdzenia zdefiniowano specjalną stałą typu wskaźnikowego o nazwie nil. Oznacza ona wskaźnik, który nie wskazuje na nic. Może być używana z dowolnym typem wskaźnikowym.

Na poniższym rysunku możesz zobaczyć kilka struktur, które można zbudować przy pomocy takich rekordów i wskaźników. Są to:

a. lista jednokierunkowa b. lista dwukierunkowa C. lista cykliczna d. drzewo

Nil

b)

Początek Nil

Nil Koniec

48

okrojony

wyliczeniowy

znakowy

logiczne

całkowitoliczbowe

Rzeczywiste

Porządkowe

Wskaźnikowe

Strukturalne

Łańcuchowe

Proste

Standardowy

pliki

tablice

zbiory

rekordy

obiekty

TRUE

Czy Warunek

jest spełniony?

( T/N )

Blok

instrukcji 1

FALSE

Blok

instrukcji 2

FALSE

Czy Warunek

jest spełniony?

( T/F )

Blok

instrukcji 2

TRUE

Blok

instrukcji 1

N

Blok

instrukcji 3

I - zmienna sterująca

Początek- wartość początkowa zmiennej sterującej

Koniec - wartość końcowa

zmiennej sterującej

I := Początek

I > Koniec?

I := I + 1

Blok instrukcji

TRUE

FALSE

Dalsza część

programu

I - zmienna sterująca

Początek - wartość początkowa zmiennej sterującej

Koniec - wartość końcowa

zmiennej sterującej

I := Początek

TRUE

Dalsza część

programu

I < Koniec?

FALSE

Blok instrukcji

I := I - 1

Blok

instrukcji 1

Instrukcja REPEAT poleca co następuje:

powtarzaj wykonanie Bloku instrukcji 1

Bloku instrukcji 2

...

Bloku instrukcji N

pomiędzy symbolami REPEAT i UNTIL tak długo, jak Warunek (wyrażenie logiczne) będzie miał wartość False.

Blok

instrukcji 2

Blok

instrukcji N

FALSE

TRUE

Dalsza część

programu

Czy Warunek

jest spełniony?

( T/F )

FALSE

Czy Warunek

jest spełniony?

( T/F )

Dalsza część

programu

TRUE

Blok instrukcji

Wyr - Wyrażenie

W1 - wartość1

W2 - wartość2

Wn - wartośćN

Wyr = W1

TRUE

Blok instrukcji

Wartości od 1 do N - zwane stałymi wyboru muszą mieć z góry określoną wartość (nie mogą być wyrażeniami zawierającymi zmienne).

W trakcie wykonywania instrukcji CASE wykonywany jest tylko jeden Blok instrukcji. Jest to pierwszy napotkany, dla którego zdefiniowana stała wyboru (lub jedna z nich, jeżeli zdefiniowaliśmy kilka lub przedział) spełnia wyrażenie :

Wyrażenie = Wartość.

Jeżeli żadna ze stałych wyboru nie spełnia Wyrażenia, to Blok instrukcji zostanie pominięty i wykonywana jest dalsza część programu.

FALSE

Wyr = W2

TRUE

Blok instrukcji

FALSE

Wyr = Wn

TRUE

Blok instrukcji

FALSE

Dalsza część programu

Wyr - Wyrażenie

W1 - wartość1

W2 - wartość2

Wn - wartośćN

Wartości od 1 do N - zwane stałymi wyboru muszą mieć z góry określoną wartość (nie mogą być wyrażeniami zawierającymi zmienne).

W trakcie wykonywania instrukcji CASE wykonywany jest tylko jeden Blok instrukcji. Jest to pierwszy napotkany, dla którego zdefiniowana stała wyboru (lub jedna z nich, jeżeli zdefiniowaliśmy kilka lub przedział) spełnia wyrażenie :

Wyrażenie = Wartość,

bądź Blok instrukcji po ELSE, jeżeli żadna ze stałych wyboru nie spełnia Wyrażenia.

TRUE

Wyr = W1

Blok instrukcji

FALSE

TRUE

Wyr = W2

Blok instrukcji

FALSE

TRUE

Wyr = Wn

Blok instrukcji

FALSE

Dalsza część programu

Blok instrukcji

---