Język Pascal

Program

[ nagłówek ]
[ deklaracje ]
  blok instrukcji 

begin
end.

Nazwy

Deklaracje typów

Instrukcja przypisania

const
   a = 100;
ver
   b: integer;
begin
   b:=a;  {   <--- instrukcja przypisania  }
   writeln(a:5, b:5)
end.   

  100  100

Instrukcje z wyborem (selekcje)

if WARUNEK then INSTRUKCJA;
if WARUNEK then INSTRUKCJA else INSTRUKCJA;
case ZMIENNA of
  nazwa1: INSTRUKCJA1;
  nazwa2: INSTRUKCJA2;
  ...
  nazwa3: INSTRUKCJA3
  else    INSTRUKCJA
end;

Zadanie 1: Schematy selekcji. Narysuj schematy blokowe instrukcji selekcji języka Turbo Pascal.

Instrukcje wejścia-wyjścia

Przykład. Poniższy program wczytuje proste dane.
{
UWAGA.
w nawiasach klamrowych można umieszczać uwagi
dotyczące wszystkiego. Nawiasy te powodują,
że nie należąone do programu
i sa pomijane przez translator.
}

var
  a: real;      { a jest typu rzeczywistego }
  b: integer;   { b jest typu całkowitego }
  c: char;      { c jest typu znakowego }
begin
  Readln(a);    { czytaj z konsoli wartość a }
  Readln(b);    { czytaj z konsoli ,,        b }
  Readln(c);    { ,,                         c }
  Writeln(a);   { wypisz zawartość zmiennej a}
  Writeln(b);   { ,, }
  Writeln(c);   { ,, }
end.

Instrukcje powtarzania

while WARUNEK do INSTRUKCJA
repeat INSTRUKCJA until WARUNEK
for ZMIENNA:=POCZATEK to|downto KONIEC do INSTRUKCJA

Typy złożone i ich deklaracje

Abstrakcyjne typy danych (ATD)

• tablice (array)
• rekordy (record)
• zbiory (sets)
• łańcuchy (strings)
• stosy (stacks)
• kolejki (queues)
• listy połączone (lists)
• drzewa (trees)
• grafy (graphs)

Tablice

var
   x: array[0..99] of real;

const
   n=19; m=29;
{ 1 }
var
  A: array [0..n] of array [0..m] of real;
{ 2 }
var
  B: array [0..n,0..m] of real;
{lub 3 }
type
   duZa=array [0..n,0..m] of real;
var
   C: duZa;  

function Hilbert(k, w: integer): real;
begin Hilbert:=1.0/(w+k-1.0) end;

Rekordy

Przykład. Liczbę zespoloną z zapisujemy w postaci kartezjańskiej z=x+iy albo w postaci biegunowej z=re^ϕ. W Pascalu możemy do tego celu użyć typu rekordowego.

type
   PostacZespolonej = (kartezjanska, biegunowa);
   Zespolona = record
                  case Postac : PostacZespolonej of
                     kartezjanska : (x, y : real);
                     biegunowa : (r, fi : real)
                  end;

Przykład.

procedure CzytajZespolona(var z: Zespolona);
var
   Kod: char;
begin
   Read(Kod);
   Write(Kod);   (* Echo *)
   case Kod of
   'k': begin
           z.postac:=kartezjanska;
           Read(z.x);
           Read(z.y)
        end;
   'b': begin
           z.postac:=biegunowa;
           Read(z.r);
           Read(z.fi)
        end;
   else
        Write('Zle dane')
   end
end;

procedure SumujZ(z1, z2: Zespolona; var SumaZ: Zespolona);
(*
      Dodawanie liczb zespolonych, które moga byc
      reprezentowane w~postaci kartezjanskiej lub
      biegunowej
*)
var
   x1, y1, x2, y2: real;
begin
   if z1.postac = kartezjanska then
     begin x1:=z1.x; y1:=z1.y end
   else
     begin
        x1:=z1.r * cos(z1.fi);
        y1:=z1.r * sin(z1.fi)
     end;
   if z2.postac = kartezjanska then
     begin x2:=z2.x; y2:=z2.y end
   else
     begin
        x2:=z2.r * cos(z2.fi);
        y2:=z2.r * sin(z2.fi)
     end;
   SumZ.postac:=kartezjanska;
   SumZ.x:=x1+x2;
   SumZ.y:=y1+y2
end; (* SumZ *)

Zadanie 2: Rekordy. Zmodyfikować procedurę SumujZ tak, by wynik był zapisany w postaci biegunowa w przypadku, gdy obie liczby są podane w tej postaci, a w postaci kartezjańskiej w innych przypadkach.

Zadanie 3: Liczby zespolone 1. Napisać procedurę mnożenia liczb zespolonych MultZ.

Zadanie 4: Liczby zespolone 2. Napisać procedurę odejmowania liczb zespolonych, która korzysta z procedury SumujZ i procedury negacji liczby zespolonej MinusZ, która zmienia znak liczby zespolonej na przeciwny (też napisać).

Zadanie 5: Zety. Napisać procedurę dzielenia liczb zespolonych, która używa procedury mnożenia MultZ oraz procedury odwracania liczb zespolonych InvZ.

Zadanie 6: Zety z tablicami. Powtórz wszystkie powyższe ćwiczenia używając tablic.

Zadanie 7: Ułamki proste. Korzystając z definicji ulamka prostego napisz zbiór procedur i funkcji, które dodają, mnożą, dzielą, odejmują, czytają i wypisują ułamki, zawsze w postaci q/p. Skorzystaj ze struktury record a. Umieść napisane procedury w bibliotece modułów (Unit) o nazwie ulamki. Ułamki można upraszczać korzystając z algorytmu Euklidesa. Funkcję Euklid dodaj do biblioteki modułów.

Zbiory (sets)

var
   A: set of WyliczeniowyTypDanych;

Przykład.

type
   Dzien=(Po,Wt,Sr,Cz,Pt,So,Ni);
   Znaki=set of char;
   Cyfry=set of 0..9;
   Dni=set of Dzien;
   Litery=set of 'A'..'Z';
const
   cyfry_parzyste: Cyfry=[0,2,4,6,8];
   samogloski: Litery=['A','E','I','O','U','Y'];
var
   D: Dni;

Łańcuchy (strings)

Przykład.

const
   DlugoscLinii=80;
type
   Nazwisko=string[25];
   Imie=string[25];
   Linia=string[80];

Przykład.

var
   Nazwisko: string[25];
begin
   Nazwisko:='Kowalski';
   writeln('Dzien dobry panie ', Nazwisko)
end.

Przykład.

  {StrCopy.PAS}
  {Sample code for the StrCopy function.}
  { For Windows: }
  { uses Strings, WinCrt; }
  uses Strings;
  var
   S: array[0..15] of Char;
  begin
   StrCopy(S, 'Turbo Pascal');
   Writeln(S);
  end.

Footnotes: