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) x2
Sqrt(x)
Exp(x) ex
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 38
Single (4B) 1,5 * 10 -45 ... 3,4 * 10 38
Double (8B) 5,0 * 10 -324 ... 1,7 * 10 308
Extender (10B) 3,4 * 10 -4932 ... 1,1 * 10 4932
Comp (8B) -2 63 + 1 ... 2 63 -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;
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.
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 :
Zmiennej sterującej I zostaje przypisana wartość początkowa Początek.
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.
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 :
Zmiennej sterującej I zostaje przypisana wartość początkowa Początek.
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.
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.
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.
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 wcinij 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;
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.
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.
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ść.
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ż 216 = 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 komputera 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 powoduje 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 przechowywanie 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 pokazuje 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