Informatyka dla kierunku Mechanika
gmwojcik (c) 2010-2011
1 / 1
wprowadzenie
Materiały mają na celu zapoznanie studentów pierwszego roku
kierunku Mechanika z podstawami programowania algorytmów na
podstawie języka Pascal.
2 / 1
Deklaracje i typy zmiennych
Typy całkowite
var
a:Shortint; { zmiennej a przypisane mogą być liczby
z zakresu od -128 do 127 - liczba bajtów: 1 }
b:Byte; { zmiennej b przypisane mogą być liczby
z zakresu od 0 do 255 - liczba bajtów 1 }
c:Integer; { zmiennej c przypisane mogą być liczby
z zakresu od -32768 do 32767 - liczba bajtów: 2 }
d:Word; { zmiennej d przypisane mogą być liczby
z zakresu od 0 do 65535 - liczba bajtów: 2 }
e:Longint; { zmiennej e przypisane mogą być liczby
4 bajty: od -2147483648 do 2147483647}
3 / 1
Deklaracje i typy zmiennych
Typy rzeczywiste
var
f:Real; { zmiennej f przypisane mogą być liczby
z zakresu od 2.9E-39 do 1.7E38 - liczba bajtów: 6 }
g:Single; { zmiennej g przypisane mogą być liczby
z zakresu od 1.5E-45 do 3.4E38 - liczba bajtów: 4 }
h:Double; { zmiennej h przypisane mogą być liczby
z zakresu od 5.0E-324 do 1.7E308 - liczba bajtów: 8 }
i:Extended; { zmiennej i przypisane mogą być liczby
z zakresu od 1.9E-4951 do 1.1E4932 - liczba bajtów: 10}
j:Comp; {zmiennej przypisane są liczby całkowite
z zakresu od -9.2E18 do 9.2E18 - liczba bajtów: 8 }
4 / 1
Deklaracje i typy zmiennych
Typy znakowe
var
k:Char; { zmiennej k przyporządkowany
jest jeden znak - char - 1 bajt }
l:String; { zmiennej l przyporządkowano
łańcuch znaków - liczba bajtów: 255 }
5 / 1
Deklaracje i typy zmiennych
Zamiana zmiennych
program zamiana;
var
A, B : String;
ZmiennaPom : String;
begin
A :=  pierwszy tekst ; B :=  drugi tekst ;
writeln ( A:  , A,  , B:  , B);
ZmiennaPom := A;
A := B;
B := ZmiennaPom;
writeln ( A:  , A,  , B:  , B);
readln;
end.
6 / 1
Deklaracje i typy zmiennych
i niespodzianka
program student;
var
A, B : Byte;
begin
A := 0; B := 18;
writeln ( A:  , A,  , B:  , B);
A := B-A; B := B-A; A := B+A;
writeln ( A:  , A,  , B:  , B);
readln;
end.
7 / 1
Stałe w Pascalu
Deklaracje stałych
Stałe deklaruje się w sekcji const:
program loguj;
const
user =  gmwojcik ;
begin
writeln ( Uzytkownik:  +user+  zalogowany! );
readln;
end.
8 / 1
Stałe w Pascalu
Uwaga!
Do stałych możemy się odwoływać z każdej części programu, jej
wartość jest jak sama nazwa wskazuje stała i nie można jej
zmienić. Stałymi mogą być również liczby, oczywiście wtedy już
bez  122.12 tylko wprost stala = 122.12.
9 / 1
Instrukcja przypisania
Typowe przypisanie
program przypisanie1;
const
Pi = 3.14; { w stałych piszemy samo }
var
litera: char;
godzina, minuta, sekunda: integer;
suma: real;
begin
{przypisanie w Pascalu to  := }
litera:= X ;\\
writeln( Zmiennej litera przyporządkowano:  , litera);
10 / 1
Instrukcje warunkowe
Warunki są wszędzie
Najprostszy warunek to:
Składnia
IF warunek (lub warunki, o tym niżej) THEN instrukcje
11 / 1
Instrukcje warunkowe
Jest to typ okrojony, pełna instrukcja warunkowa wygląda tak:
Składnia
IF warunek (lub warunki, o tym niżej) THEN instrukcje ELSE
instrukcje
12 / 1
Instrukcje warunkowe
Instrukcja warunkowa c.d.
Zobrazujmy to na przykładzie prostego programu:
Przykład
program warunkowy;
var x: integer;
begin
write( Podaj jakas liczbe typu integer:  );
readln(X);
if(X > 0) then writeln( Liczba wieksza od zera! ) gdy warunek X
> 0 jest prawdziwy
else writeln( Wprowadzona liczba jest albo zerem, albo jest
ujemna );
readln;
end.
13 / 1
Instrukcja wyboru
Instrukcja Case . . .
Spójrzmy zatem na problem z ocenianiem jeszcze raz:
Przykład
CASE Wynik DIV 10 OF
10,9 : Ocena := 5.0 ;
8 : Ocena: = 4.0;
7 : Ocena: =4.0 ;
6 : Ocena: = 3.5 ;
5 : Ocena: =3.0 ;
0,1,2,3,4: Ocena:= 2.0
END
14 / 1
Instrukcja wyboru
Jeszcze o warunku . . .
Przykład
if (x >= 0) AND (x <= 1) THEN
writeln( Ten przedzial jest zbyt maly! )
ELSE oblicz(x);
Można umieszczać warunki w warunkach, korzystać z operatorów
logicznych: AND, OR, NOT, XOR.
15 / 1
Pascalowe pętle
Pętla FOR
Są dwie odmiany: pętla idąca w górę i w dół.
Składnie odpowiednio wyglądają:
FOR licznik:=wartosc1 TO wartosc2 DO instrukcje;
{dla wartosc1 < wartosc2, pętla rosnąca}
FOR licznik:=wartosc1 DOWNTO wartosc2 DO instrukcje;
{dla wartosc1 > wartosc2, pętla malejąca}
16 / 1
Pascalowe pętle
Pętla FOR c.d.
Uwagi: licznik jest typu całkowitego, zmienna licznik zmienia się o
1, nie można wykonywać skoków.
program trojkat;
var a,b: integer;
begin
for b:= 1 to 5
do
begin {zaczyna rysowac trojkat}
write( * );
17 / 1
Pascalowe pętle
Pętla FOR c.d.
for a:=1 to 2*b-2
do
write( * );
writeln;
end;
{czeka na nacisniecie klawisza enter,
pozniej konczy program}
readln;
end.
18 / 1
Pascalowe pętle
Pętla REPEAT UNTIL
Pętla jest tak długo wykonywana dopóki warunek wyjścia nie jest
prawdziwy.
Składnia:
REPEAT
wypisz(tekst,ile);
UNTIL keypressed;
19 / 1
Pascalowe pętle
Pętla WHILE
While różni się tylko tym od Repeat, że fałsz jest warunkiem
wyjścia z pętli. Składnia wygląda tak:
Składnia:
WHILE warunek DO instrukcje;
20 / 1
Pascalowe pętle
Pętla WHILE c.d.
PROGRAM Suma;
CONST N = 1000 ;
VAR K,SUM,X : Integer ;
BEGIN
Writeln( Wykonanie programu kończy się po wprowadzeniu );
Writeln( 1000 liczb. To nie jest zabawa ani gra. ) ;
K := 1 ;
SUM := 0 ;
WHILE K <= N
DO BEGIN {Początek treści pętli}
Write( Wprowadz
liczbę typu Integer: ) ;
Read(X) ;
Writeln ;
21 / 1
Pascalowe pętle
Pętla WHILE c.d.
SUM := SUM + X ;
Writeln( Suma częściowa; ,SUM:6) ;
K := K + 1
END ; {Koniec treści pętli}
Writeln ;
Writeln( Suma N= ,N, liczb wynosi: ,SUM:6);
END.
22 / 1
Pascalowe pętle
Pętle zagnieżdżone
Pierwszy program spowoduje wyświetlenie trzykrotnie ciągu liter
od  a do  z , każdy ciąg w nowej linii.
var k: integer;
litera: char;
begin
for k := 1 to 3 do { petla zewnetrzna }
begin
for litera :=  a to  z { petla wewnetrzna }
do write(litera:2);
writeln;
end;
readln;
end.
23 / 1
Tablice w Pascalu
Tablice to nic innego jak posegregowane w tabelkach dane.
Tablice w Pascalu można zadeklarować na dwa sposoby -
pierwszym - najprostszym jest użycie dyrektywy ARRAY, druga
metoda to stworzenie nowego typu tablicowego.
24 / 1
Przykład
program tablice;
var
{ dla uproszczenia niech tablica X bedzie globalna }
X: ARRAY[1..10] of integer;
i: integer;
{ 1..10 oznacza, ze jest 10 elementow o indeksach
od 1 do 10. dla tablic znakowych mozna wpisac  A .. Z
(i takie beda indeksy np.: X[ Q ]) }
25 / 1
Przykład c.d.
procedure zapelnij;
begin
for i:=1 to 10 do
begin
x[i]:=i*i;
end;
end;
26 / 1
Przykład c.d.
procedure pokaz;
begin
for i:=1 to 10 do
begin
write(x[i],   );
end;
end;
27 / 1
Przykład c.d.
begin
zapelnij;
pokaz;
readln;
end.
28 / 1
Tablice jako typ
Typ tablicowy wygląda następująco:
program tab_type;
type
typ_tablicowy = ARRAY [1..10] of integer;
var
i: integer;
x: typ_tablicowy;
29 / 1
Tablice wielowymiarowe
definiujemy w sposób następujący:
var A: ARRAY [od..do] OF ARRAY[od..do] OF jakis_typ
30 / 1
Tablice wielowymiarowe
albo w wersji skróconej:
var A: ARRAY [od..do,od..do] OF jakis_typ
31 / 1
Przykład
Jeśli chcemy mieć macierz 12 elementową składająca się z 4
kolumn i 3 rzędów:
var macierz: ARRAY[1..4,1..3] OF integer;
32 / 1
Tabliczka mnożenia
program macierz;
var
{ dla uproszczenia niech tablica X bedzie globalna }
X: ARRAY[1..10,1..10] of integer; { macierz 10 na 10 }
i,j: integer; { indeksy komorek, tez globalne }
33 / 1
Tabliczka mnożenia c.d.
procedure zapelnij;
begin
for i:=1 to 10 do { indeksy wierszy }
begin
for j:=1 to 10 do { indeksy kolumn }
X[i,j]:=i*j;
end;
end;
34 / 1
Tabliczka mnożenia c.d.
procedure pokaz;
begin
for i:=1 to 10 do
begin
for j:=1 to 10 do
begin
write(X[i,j]:3,  );
end;
writeln; {przejscie do nowej linii}
end;
end;
35 / 1
Tabliczka mnożenia c.d.
begin
zapelnij;
pokaz;
readln;
end.
36 / 1
Tablice znaków
W Pascalu, w przeciwieństwie do C, trochę trudniej deklaruje się
tablice znaków.
Jeśli indeksem jest litera:
program indeks_znak;
var TabZnak: array[ A .. Z ] of char;
Znak: char;
begin
for Znak :=  A to  Z do TabZnak[Znak] := Znak;
for Znak :=  A to  Z do write(  ,TabZnak[Znak]);
readln;
end.
37 / 1
Tablice znaków
Jeśli indeksem jest wartość litery:
program indeks_integer;
var TabZnak: array[Ord( A )..Ord( Z )] of char;
i: integer;
{ ord( A ) = 65, ord( Z ) = 90
czyli tablica ma zakres 65..90 }
begin
for i := Ord( A ) to Ord( Z ) do TabZnak[i] := Chr(i);
for i := 65 to 90 do write(  ,TabZnak[i]);
readln;
end.
38 / 1
Tablice znaków
Index liczbowy:
program indeks_integer;
var TabZnak: array[0..25] of char;
i: integer;
begin
for i := 0 to 25 do TabZnak[i] := Chr(Ord( A )+i);
{ tu jest podobnie, ord zamienia znak na kod litery
ASCII, potem dodawana jest wartosc  i a potem
wszystko z powrotem jest zamieniane na znak za
pomoca funkcji Chr }
for i := 0 to 25 do write(  ,TabZnak[i]);
readln;
end.
39 / 1
Procedury
Procedury
Procedury. To jest coś dla osób, które nie lubią się powtarzać. Gdy
wiemy, że np. w naszym programie będziemy używali kilka razy
tego samego kodu z
ródłowego możemy umieścić go w procedurze i
póz
niej, z dowolnego miejsca programu, odwoływać się do niej.
40 / 1
Procedury
Przykład 1
program przyklad_prostej_procedury;
procedure footer;
begin
writeln ( Korzystałeś z mojego programu );
end;
begin
footer; {odwołanie się do naszej procedury,
która wypisze tekst}
end.
41 / 1
Procedury
Procedury z parametrami
Procedury mogą także posiadać parametry, przykłady takie jak
poniżej. Deklaracja i wywoływanie procedur z parametrami
wygląda następująco:
deklaracja:
procedure QWQ (A, B : Integer; C: Real)
a jej wywołanie wygląda następująco:
QWQ(A,B,C);
42 / 1
Procedury
Przykład 2
PROGRAM Sortowanie;
PROCEDURE Czytanie;
{Procedura wczytywania sekwencji N liczb}
PROCEDURE Sort;
{Procedura sortowania wczytanej sekwencji N liczb}
PROCEDURE Ekran;
{Procedura wydruku sekwencji N liczb}
43 / 1
Procedury
Przykład 2 c.d.
BEGIN {programu}
Czytanie;
Sort;
Druk;
END. {programu}
44 / 1
Procedury
Przykład 2 c.d.
PROGRAM Sortowanie;
CONST N = 1000 ;
TYPE Indeks == O..N ;
Wektor = ARRAY[Indeks] OF Real ;
VAR
Tab1 : Wektor ; LI : Indeks ;
45 / 1
Procedury
Przykład 2 c.d.
PROCEDURE Czytanie(VAR Beta : Wektor? VAR Num : Indeks);
VAR Symbol : Char ;
BEGIN {Czytanie}
Num := O ;
REPEAT
Num := Num+1; Read(Beta[Num], Symbol)
Until Symbol =  *
END; {Czytanie}
46 / 1
Procedury
Przykład 2 c.d.
PROCEDURE Sort(VAR Ciąg : Wektor ; M : Indeks) ;
VAR I,ZAM ; Indeks ; B : Real ;
BEGIN {Sort}
REPEAT
ZAM := O ;
47 / 1
Procedury
Przykład 2 c.d.
FOR I := l TO M - l DO BEGIN
IF Ciag[I]> Ciag[I + l]
THEN BEGIN
B := Ciag[I] ;
Ciag[I] := Ciag[I + l] ;
Ciag[I + l] := B ;
ZAM := ZAM + l
END
END
UNTIL ZAM = O
END ; {Sort}
48 / 1
Procedury
Przykład 2 c.d.
PROCEDURE Druk(VAR T : Wektor ; L : Indeks) ;
VAR J : Indeks ;
BEGIN {Druk}
FOR J ;= l TO L DO Writeln(T[J]:11)
END ; {Druk}
49 / 1
Procedury
Przykład 2 c.d.
BEGIN {Sortowanie}
Czytanie(Tabi,LI) ;
Druk(Tabl,Ll);
Sort(Tabl,Ll);
Druk(Tabl,Ll) ;
END. {Sortowanie}
50 / 1
Funkcje
Funkcje
Są bardzo przydatnymi podprogramami, które mogą nas wybawić
od wpisywania wielokrotnie w różnych miejscach naszego programu
tego samego kodu z
ródłowego. Mogą zrobić wszystko co chcemy.
Kilka przykładów:
51 / 1
Funkcje
Wywołanie funkcji
Deklaracja:
function QWQ (A, B : Integer; C: Real) : Integer;
Wywołanie:
wynik:=QWQ(A,B,C);
52 / 1
Funkcje
Przykład NWD
Największy wspólny dzielnik:
program NWD;
var
A, B : Integer;
function NWD (A, B : Integer) : Integer;
{ Funkcja oblicza najwiekszy wspolny podzielnik liczb }
{ A i B. }
var
Pom : Integer;
53 / 1
Funkcje
NWD c.d.
begin
while (A<>B) do
begin
if A < B then
begin
Pom := A; A := B; B := Pom;
end;
A := A - B;
end;
{ wyjscie z funkcji z wartoscia zmiennej A }
NWD := A;
end; {-------------------------- NWD -}
54 / 1
Funkcje
NWD c.d.
begin
write ( Podaj A:  ); readln (A);
write ( Podaj B:  ); readln (B);
write ( NWD ( , A,  ,  , , B,  )  )=  )= , NWD (A, B));
readln;
end.
55 / 1
Funkcje
Funkcje rekurencyjne
na pzykładzie potęgi:
program potega_rekurencja;
var
A : Integer;
N : Byte;
function PotegaCalkowita (A: Integer; N : Byte) : Integer;
{ Funkcja oblicza N-ta potege liczby A, }
{ dla calkowitego A i naturalnego N.}
56 / 1
Funkcje
Funkcje rekurencyjne c.d.
begin
if N=0 then
PotegaCalkowita := 1
else
if (N mod 2 = 0) then
PotegaCalkowita := Sqr (PotegaCalkowita (A, N div 2))
else
PotegaCalkowita := A * Sqr (PotegaCalkowita (A, N div 2))
end; {---- PotegaCalowita ----}
57 / 1
Funkcje
Funkcje rekurencyjne c.d.
na pzykładzie potęgi:
begin
write ( Podaj liczbe:  ); readln (A);
write ( Podaj wykladnik:  ); readln (N);
writeln (A,  ^ , N,  =  , PotegaCalkowita (A, N));
readln;
end.
58 / 1
Wstęp do obsługi plików
Pliki tekstowe
Do plików tekstowych możemy wpisywać zarówno znaki jak i
liczby, możemy dodawać nowe linie, kasować całe linie, dopisywać
do istniejącego pliku etc. Pliki tekstowe inaczej też się deklaruje.
type plik_txt = text;
Pliki tekstowe dzielą się na wiersze, każdy z nich kończy się
sekwencją EOLN - znakami: CR (powrót karetki) oraz LF (przejście
do nowej linii). Cały plik z kolei kończy się sekwencją EOF -
znakami: [CTRL] + [Z] (Windows) lub [CTRL] + [D] (Linux).
59 / 1
Wstęp do obsługi plików
Pliki tekstowe
program pliki_tekstowe;
var plik: text;\\
nazwa,linia: string[80];
{wspolrzedne X ekranu maja 80, latwiej bedzie nam pozniej}
{wyswietlac zawartosc pliku, jesli plik
bedzie mial taka dlugosc wierszy}
begin
writeln( Podaj nazwe pliku, ktory mam utworzyc:  );
readln(nazwa);
assign(plik,nazwa);
60 / 1
Wstęp do obsługi plików
Pliki tekstowe
rewrite(plik);
writeln( OK - plik juz utworzony, wprowadz tekst! );
writeln( linia zawierajaca sama kropke -   .  KONIEC );
while linia <>  . do begin
readln(linia);
if linia <>  . then writeln(plik,linia);
end;
close(plik);
writeln( Dziekuje dane zostaly zapisane
do pliku:  ,nazwa);
readln;
end.
61 / 1
Wstęp do obsługi plików
Pliki tekstowe
program pliki_tekstowe;
var plik: text;
i: integer;
nazwa: string;
begin
writeln( Podaj nazwe pliku, ktory mam utworzyc:  );
readln(nazwa);
assign(plik,nazwa);
rewrite(plik);
writeln( OK - plik juz utworzony teraz zapiszemy
do niego liczby i znaki );
62 / 1
Wstęp do obsługi plików
Pliki tekstowe
write( Podaj liczbe typu integer z zakresu 1..1000:  );
readln(i);
writeln( Wprowadziles liczbe:  ,i,
jej podwojony iloczy to:  ,2*i);
writeln(plik, Wprowadziles liczbe:  ,i,
jej podwojony iloczy to:  ,2*i);
close(plik);
readln;
end.
63 / 1
Wstęp do obsługi plików
Pliki tekstowe
program pliki_tekstowe;
procedure pokaz(nazwa: string);
var plik: text;
c: char;
begin
assign(plik,nazwa);
reset(plik);
64 / 1
Wstęp do obsługi plików
Pliki tekstowe
if eof(plik) then writeln( Plik  , nazwa,  jest pusty )
else
begin
repeat
read(plik,c);
write(c);
until eof(plik);
end;
end;
65 / 1
Wstęp do obsługi plików
Pliki tekstowe
var nazwa: string;
begin
write( Podaj nazwe pliku, ktorego
zawartosc mam wczytac:  );
readln(nazwa);
writeln( Zawartosc pliku  ,nazwa, : );
pokaz(nazwa);
writeln( Koniec pliku. );
readln;
end.
66 / 1
Liczby pseudolosowe
Liczby pseudolosowe
Do generowania losowych liczb w Pascalu służy funkcja Random,
jako parametr podaje się zakres przedziału, z którego losowane
będą liczby. Funkcja Random zwraca jedynie nieujemne liczby z
zakresu 0..65536.
67 / 1
Liczby pseudolosowe
Liczby pseudolosowe
Uwaga:
Zakres jaki podajemy jako parametr do funkcji Random musi być
powiększony o 1. Poprawnym jest zapis losowania liczby z zakresu
0..32768 (maxint) jest: liczba:=random(32769);
68 / 1
Liczby pseudolosowe
Liczby pseudolosowe
Należy także pamiętać, że program używający funkcji Random
zawsze będzie losował te same liczby, chyba, że ... zainicjujemy
generator liczb losowych, robi się to używając prostej,
bezparametrowej procedury: Randomize;
randomize;
liczba:=random(32769);
69 / 1
Liczby pseudolosowe
Liczby pseudolosowe
Przykład:
program liczby_losowe;
var
{ dla uproszczenia niech tablica X bedzie globalna }
X: ARRAY[1..20] of integer;
i: integer;
70 / 1
Liczby pseudolosowe
Liczby pseudolosowe
procedure zapelnij;
begin
for i:=1 to 20 do
begin
x[i]:=random(32769);
end;
end;
71 / 1
Liczby pseudolosowe
Liczby pseudolosowe
procedure pokaz;
begin
for i:=1 to 20 do
begin
writeln(x[i]);
end;
end;
72 / 1
Liczby pseudolosowe
Liczby pseudolosowe
begin
randomize; { inicjacja generatora liczb losowych }
zapelnij;
pokaz;
readln;
end.
73 / 1
Operacje bitowe
Operacje bitowe
Nie wymagają większego komentarza ;-)
not {w C++ ~}
and {w C++ &&}
or {w C++ ||}
xor {w C++ ^}
shl {w C++ <<}
shr {w C++ >>}
74 / 1
Operacje bitowe
Operacje bitowe
Przykład:
program operacje_bitowe;
var
x,y,z: byte;
q: longint;
75 / 1
Operacje bitowe
Operacje bitowe
begin
{ bajt sklada sie z 8 bitow - tak tylko przypominam ;D }
x:=3; { bitowo 00000011 }
y:=8; { bitowo 00001000 }
x:=x and y; { wynik 00000000 }
writeln( Koniunkcja bitowa 3 i 8 to:  ,x);
y:= not y; { wynik 11110111 czyli 247 }
writeln( Negacja bitowa 8 to:  ,y);
76 / 1
Operacje bitowe
Operacje bitowe
x:=139; { bitowo 10001011 }
y:=222; { bitowo 11011110 }
z:= x or y; { wynik 11011111 czyli 223 }
writeln( Bitowa alternatywa 139 i 222 to:  ,z);
z:= x xor y; { wynik 01010101 czyli 85 }
writeln( Alternatywa wykluczajaca 139 i 222 to:  ,z);
77 / 1
Operacje bitowe
Operacje bitowe
q:=1;
q:=q shl 16; { bitowo 1 0000 0000 0000 0000 ;D }
writeln( czy wiesz, ze 2 do 16 potegi to:  ,q);
{ shl  mnozy przez dwa, shl  dzieli przez dwa
operacje bitowe wynonywane sa o wiele szybciej
niz np.: tradycyjne mnozenie }
q:=153;
q:=q shl 3; { 2^3 = 8 }
writeln( 153 * 8 =  ,q);
78 / 1
Operacje bitowe
Operacje bitowe
q:=153;
q:=q shr 1; { 2^1 = 2 }
writeln( 153 / 2 =  ,q);
readln;
end.
79 / 1
Rekordy
Rekordy
Rekordy. To dane, które mogą być wieloczłonowe, np. napisałeś
grę - możesz wstawić do niej dane jako rekord, który będzie składał
się z daty, ksywy zawodnika, liczby punktów, liczby zdobytych
bonusów etc. Wszystko to można umieścić w jednej zmiennej. Na
tej samej zasadzie pracują programy np. w bibliotekach. Mamy:
tytuł książki, autora, kto ją wypożyczył, od kiedy ją trzyma etc.
80 / 1
Rekordy
Rekordy
Przykład deklaracji rekordu dla biblioteki:
TYPE InfoBibl = RECORD
{ ponizej podaje pola rekordu i ich typ }
Tytul,Autor: string[1..30];
Cena: Real ;
IlEgz: 0..100 ;
Status: Char
END ;
VAR
Book : InfoBibl ;
81 / 1
Rekordy
Rekordy
Do pól rekordu Book możemy wpisywać wartości instrukcjami
przypisania:
Book.Tytuł :=  Organizacja maszyn cyfrowych
Book.Autor :=  Yaochan Chu
Book.Cena := 150.0;
Book.IlEgz := 10;
Book.Status:=  C
82 / 1
Rekordy
Rekordy
Tablice rekordów możemy kopiować wprost:
Book2 := Book;
Book3 := Book;
83 / 1
Rekordy
Rekordy
Proste, ale prawdziwe wtedy i tylko wtedy, gdy Book, Book2 i
Book3 są tego samego typu czyli: InfoBibl. Sprawa może się
skomplikować, gdy mamy dwa różne typy rekordów, nazwy pól są
np. inne, ale typy pól są takie same. Wtedy trzeba  ręcznie
kopiować pole do pola. W poniższym przykładzie mamy dwa
rekordy, są one niemal identyczne, tylko inaczej nazywają się ich
pola.
84 / 1
Rekordy
Rekordy
TYPE Info1 = Record
wiek : 0..120 ;
p : char
end;
Info2 = Record
lata: 0..120 ;
sex: char
end;
85 / 1
Rekordy
Rekordy
VAR Pierwszy : Info1 ; Drugi : Info2;
Pierwszy.wiek : = Drugi.Lata ;
Drugi.sex := Pierwszy.p ;
86 / 1
Rekordy
Rekordy
Pokaz rekordów
program pokaz_rekordow;
type licznik = record
dzial : string[20];
autor : string[20];
ile : longint;
end;
var stats : licznik;
87 / 1
Rekordy
Rekordy
procedure pobierz;
begin
writeln( Podaj dzial, pole moze zawierac 20 liter:  );
readln(stats.dzial);
writeln( Podaj autora, pole moze zawierac 20 liter:  );
readln(stats.autor);
writeln( Podaj ilosc wywolan, maks. longint:  );
readln(stats.ile);
end;
88 / 1
Rekordy
Rekordy
procedure pokaz;
begin
write( Dzial:  );
writeln(stats.dzial);
write( Autor:  );
writeln(stats.autor);
write( Ilosc wywolan:  );
writeln(stats.ile);
end;
89 / 1
Rekordy
Rekordy
begin
pobierz;
pokaz;
readln;
end.
90 / 1
Rekordy
Prosta baza danych
program prosta_baza;
type licznik = record
dzial : string[20];
autor : string[20];
ile : longint;
end;
91 / 1
Rekordy
Prosta baza danych
{ wszystko globalnie }
const MAX=3;
var stats : ARRAY[1..MAX] of licznik;
i: integer;
92 / 1
Rekordy
Prosta baza danych
procedure pobierz;
begin
writeln( +----------------------------+ );
for i:=1 to MAX do
begin
writeln( REKORD nr:  ,i);
writeln( Podaj dzial, pole moze zawierac 20 liter:  );
readln(stats[i].dzial);
writeln( Podaj autora, pole moze zawierac 20 liter:  );
readln(stats[i].autor);
writeln( Podaj ilosc wywolan, maks. longint:  );
readln(stats[i].ile);
writeln;
end;
end;
93 / 1
Rekordy
Prosta baza danych
procedure pokaz;
begin
writeln( +----------------------------+ );
for i:=1 to MAX do
begin
writeln( REKORD nr:  ,i);
write( Dzial:  );
writeln(stats[i].dzial);
write( Autor:  );
writeln(stats[i].autor);
write( Ilosc wywolan:  );
writeln(stats[i].ile);
writeln;
end;
end;
94 / 1
Rekordy
Prosta baza danych
begin
pobierz;
pokaz;
readln;
end.
95 / 1
Rekordy
Instrukcja WITH
WITH jest instrukcją dzięki której oszczędzimy trochę na pisaniu w
kółko nazwy rekordu. Załóżmy, że dokonujemy wpisu do zmiennej
Book będącej rekordem typu BiblInfo. Najprościej jest zrobić:
book.tytul:= qwq ;
book.autor:= wqq
96 / 1
Rekordy
Instrukcja WITH
Czy na pewno? Za każdym razem podajemy  book- nie abyśmy
byli leniwi, ale możemy  związać wczytywane zmienne z polami
rekordów. Np.:
with book do
begin
tytul:= qwq;
autor:= wqq ;
end; { dalej juz zmienne nie beda wiazane z rekordem book }
97 / 1
Rekordy
Rekordy z wariantami
Są to tak zwane zmienne rekordowe. Rekordach z wariantami
używane są jeśli piszemy uniwersalne programy, np.: operujemy na
stopach i metrach jednocześnie i to od użytkownika będzie zależało
czy chce posługiwać się takim a nie innym systemem
jednostkowym.
98 / 1
Rekordy
Rekordy z wariantami
type
miary = record
case rodzaj: (ang,pol) of
ang: (stopy,cale: integer);
pol: (metry,centym: integer)
end;
99 / 1
Rekordy
Rekordy z wariantami
Teraz pokażę jak wykorzystać to w programie. Program nie jest
ambitny, ale przynajmniej pokazuje możliwości i zalety wariantów.
program warianty;
type
miary = record
case rodzaj: (ang,pol) of
ang: (stopy,cale: integer);
pol: (metry,centym: integer)
end;
var wymiary: miary;
wybor: char;
100 / 1
Rekordy
Rekordy z wariantami
procedure pobierz;
begin
if wymiary.rodzaj = pol then
begin
writeln( Podaj po spacji metry i centymetry:  );
with wymiary do begin
readln(metry,centym);
end;
end
101 / 1
Rekordy
Rekordy z wariantami
else
begin
writeln( Podaj po spacji stopy i cale:  );
with wymiary do begin
readln(stopy,cale);
end;
end;
end; {procedury}
102 / 1
Rekordy
Rekordy z wariantami
begin
wymiary.rodzaj:=pol;
writeln( Domyslnym systemem miar jest polski - metrowy,
wpis
readln(wybor);
if upcase(wybor) =  Z then
begin
wymiary.rodzaj:=ang;
{ jeszcze nie wprowadzilem rekordow}
writeln( Od teraz miary beda podawne w stopach );
end;
103 / 1
Rekordy
Rekordy z wariantami
writeln;
pobierz;
{tu mozna umiescic jakies dalsze instrukcje...}
readln;
end.
104 / 1
Obiekty
Obiekty
Obiekt. Z czym to się je? Mówiąc krótko: zbiór procedur i funkcji
(czyli metod), za pomocą których obsługuje się dane, które obiekt
zawiera. A nieco dłużej... Wyobraz
sobie moduł (unit) z
procedurami, funkcjami i danymi. Procedury i funkcje są
powiązane tematycznie, tzn. wszystkie służą np.: do obsługi
ekranu albo do obrabiania łańcucha znaków (stringa). Gdzieś w
głębi biblioteki znajdują się zmienne, w któych są trzymane
niezbędne dane (zawartość stringa czy też bufor na ekran). Ty nie
wiesz dokładnie, gdzie są TE dane, więcej: nie obchodzi Cię to.
105 / 1
Obiekty
Obiekty
Teoretycznie nie masz do nich bezpośredniego dostępu, możesz je
odczytywać i modyfikować tylko za pośrednictwem metod - funkcji
i procedur - którymi Twoja biblioteka dysponuje. I to jest meritum
obiektów: całkowite oddzielenie danych od reszty kodu; dostęp do
nich jest możliwy tylko w obrębie modułu lub obiektu. Tylko
metody obiektu działają na jego danych (i tylko jego danych).
106 / 1
Obiekty
Obiekty
Jeszcze jedna ważna rzecz: tą hipotetyczną bibliotekę możesz
powielać w pamięci, tzn. możesz zwiększyć ilość danych (np.:
obsługiwać dwa, trzy, cztery (...) stringi), które nadal będą
obsługiwane tymi samymi metodami. Wynika z tego jeden
wniosek: obiekty łatwo się modyfikuje, często wielokrotnie łatwiej,
niż z
wykłe procedury - czyli te nie powiązane z danymi.
107 / 1
Obiekty
Obiekty
Przykład:
type
TDane = record
a : string;
b : integer;
end;
108 / 1
Obiekty
Obiekty
oraz zespół procerdur pracujących na rekordzie. . .
procedure SetA(const s : string;var dane : TDane);
begin
dane.a := s
end;
109 / 1
Obiekty
Obiekty
procedure SetB(const i : integer;var dane : TDane);
begin
dane.b := i
end;
110 / 1
Obiekty
Obiekty
function GetA(const dane : TDane) : string;
begin
GetA := dane.a
end;
111 / 1
Obiekty
Obiekty
function GetB(const dane : TDane) : integer;
begin
GetB := dane.b
end;
112 / 1
Obiekty
Obiekty
Obiekt grupujący powyższy rekord z procedurami mógłby wyglądać
następująco:
type
TDane = object
a : string;
b : integer;
procedure SetA(const s : string);
procedure SetB(const i : integer);
function GetA : string;
function GetB : integer;
end;
113 / 1
Obiekty
Obiekty
procedure TDane.SetA(const s : string);
begin
a := s
end;
114 / 1
Obiekty
Obiekty
procedure TDane.SetB(const i : integer);
begin
b := i
end;
115 / 1
Obiekty
Obiekty
function TDane.GetA : string;
begin
GetA := a
end;
116 / 1
Obiekty
Obiekty
function TDane.GetB : integer;
begin
GetB := b
end;
117 / 1
Obiekty
Obiekty
Tyle wcześniej było o ochronie danych, której jak do tej pory nie
zapewniliśmy (do danych można było dostać się ręcznie, bez
pośrednictwa metod obiektu). Dzieje się tak dlatego, że domyślnie
wszystkie metody i dane w obiekcie są publiczne - tzn. są widoczne
na zewnątrz obiektu. Ale nie zawsze jest to nam na rękę, więc
używa się słów private i public, które regulują pokazywanie danych
i metod na zewnątrz obiektu.
118 / 1
Obiekty
Obiekty
type
TDane = object
private
a : string;
b : integer;
119 / 1
Obiekty
Obiekty
public
procedure SetA(const s : string);
procedure SetB(const i : integer);
function GetA : string;
function GetB : integer;
end;
120 / 1
Obiekty
Obiekty
Wszystkie metody są publiczne, natomiast dane są ukryte
( prywatne ). W praktyce ochrona danych jest kiepsko
dopracowana i zabezpiecza je tylko na zewnątrz modułu - czyli
wewnątrz modułu, w którym został zadeklarowany obiekt,
wszystkie jego pola są publiczne. W zasadzie taki zakres ochrony
powinien wystarczać, bo jeśli masz dostęp do kodu z
ródłowego, to
i tak możesz zrobić z danymi to, co Ci się podoba - a jedynym
zabezpieczeniem przed tym jest rozprowadzanie kodu w postaci
skompilowanej biblioteki (albo użycie parsera zamazującego kod).
121 / 1
Dziedziczenie
Podstawy dziedziczenia
Więc teraz dziedziczenie: sedno obiektów. Załóżmy, że chcemy
mieć dwie wersje obiektu TDane - jedną obsługującą dodatkowo
liczby rzeczywiste, a drugą dodatkowo longinty. Czy musimy pisać
całość na nowo? Nie! Wykorzystamy dziedziczenie.
122 / 1
Dziedziczenie
Podstawy dziedziczenia
type
TDane1 = object(TDane)
x : real;
procedure SetX(const r : real);
function GetX : real;
end;
123 / 1
Dziedziczenie
Podstawy dziedziczenia
TDane2 = object(TDane)
x : longint;
procedure SetX(const r : real); {!!!}
function GetX : longint;
end;
124 / 1
Dziedziczenie
Podstawy dziedziczenia
procedure TDane1.SetX;
{nie trzeba powtarzać nagłówka z deklaracją parametrów}
begin
x := r
end;
125 / 1
Dziedziczenie
Podstawy dziedziczenia
function TDane1.GetX;
begin
GetX := x
end;
126 / 1
Dziedziczenie
Podstawy dziedziczenia
procedure TDane2.SetX;
begin
x := round(r)
end;
127 / 1
Dziedziczenie
Podstawy dziedziczenia
function TDane2.GetX;
begin
GetX := x
end;
128 / 1