Kurs Pascala

download report

Transcript Kurs Pascala

Materiały do zajęć z przedmiotu: Narzędzia i języki programowania

Programowanie w języku PASCAL

Część 6: Tablice, rekordy, zbiory © Jan Kaczmarek

Typy strukturalne

Typy strukturalne są używane do opisu obiektów złożonych, tzn. takich, które w danym momencie przechowują nie jedną, ale kolekcję wielu wartości.

Typy strukturalne definiuje się na podstawie pewnych schematów strukturalizacji podając typy składowych i metodę strukturalizacji, określającą mechanizm dostępu do danych elementów struktury.

W Pascalu mamy cztery rodzaje struktur: - tablice – opisywane typami tablicowymi - rekordy – opisywane typami rekordowymi - zbiory – opisywane typami zbiorowymi - pliki – opisywane typami plikowymi

Tablice

Tablica składa się z elementów jednakowego typu, przy czym każdy element tablicy może być jawnie nazwany (wskazany), a liczbę elementów ustala się w chwili opisywania (deklarowania) tablicy i nie można tej liczby zmienić.

Tablica posiada regularną strukturę i dlatego jest używana do reprezentowania regularnych układów danych, np. wektorów: -4 6 12 -3 0 10 2 4 lub macierzy: 8 9 2 7 9 5 5 7 1 5 6 3 3 5 3 7 8 10 2 1 1 9 4 4 7 5 3 2 11 3 2 1 0 6 2 9 2 5 9 8 12 1

Typy tablicowe

Definicja typu tablicowego ma postać:

type identyfikator-typu = array [typy-indek sów] of typ-bazowy;

gdzie: typy indeksów – oddzielone przecinkami opisy typów porządkowych (najczęściej wykorzystuje się tu typy okrojone lub wyliczeniowe) typ-bazowy – dowolny typ prosty lub strukturalny.

Rozmiar tablicy ustalony jest na etapie kompilacji.

Przykłady:

type

wektor =

array

macierz =

array

[1..10]

of

integer; [-10..10, 1..8]

of

real; tab1 =

array

[5..8, Boolean]

of

byte; tab2 =

array

[1..5]

of array

tablica =

array

[1..5, 1..20] [1..20]

of of

real; real; //10 elementów //168 elementów //8 elementów //100 elementów //100 elementów

var

T1: macierz; T2:

array

[1..20]

of

byte; //deklaracja tablicy typu macierz //deklaracja tablicy 20 elementów typu byte

Dla tablic metoda dostępu do danych nazywa się

indeksowaniem

. Indeksem może być dowolne wyrażenie zgodne z odpowiadającym mu na danej pozycji typem indeksu podanym w definicji typu tablicowego.

Wartości indeksów są wyliczane w chwili odwołania się do elementu tablicy.

Przykłady: T1[3, 7] := 2.5; T1[3][7] := 2.5; T2[5] := 5;

var

T1 : macierz; i, j : integer;

begin end

.

//wczytywanie danych do tablicy

for for

i:=-10 j:=1

to to

8 10

do do begin

write (‘kolejny element = ’); readln (T1[i, j]);

end

;

program

suma; {program znajdowania sumy n elementów jednowymiarowej tablicy A} {$APPTYPE CONSOLE} uses SysUtils;

var

n, i : integer; suma : real; A : array [1..100] of real; //tablica A ma co najwyżej 100 elementów

begin

write (‘podaj n: ‘); readln (n);

for

i:=1

to

n

do

//1<=n<=100 //wczytywanie elementów tablicy A

begin

write ( ’podaj A[’, i, ’] =’); readln (A[i]);

end

; suma := 0;

for

i:=1

to

n

do

suma := suma+A[i]; write (’suma = ’ , suma); readln;

end.

program

maximum; {program znajdowania największego elementu w tablicy A} {$APPTYPE CONSOLE} uses SysUtils;

var

n, i : integer; max : real; A : array [1..100] of real; //tablica A ma co najwyżej 100 elementów

begin

write (‘podaj n: ‘); readln (n);

for

i:=1

to

n

do

//1<=n<=100 //wczytywanie elementów tablicy A

begin

write ( ’podaj A[’, i, ’] =’); readln (A[i]);

end

; max := A[1];

for

i:=2

to

n

do if

A[i]>max

then

max := A[i]; write (’najwiekszy element = ’ , max); readln;

end.

Rekordy

Rekordem nazywamy złożoną strukturę danych, której elementy, zwane polami, mogą być (w odróżnieniu od tablic) różnych typów (prostych lub strukturalnych). Pola muszą mieć różne identyfikatory, a ich ilość jest z góry ustalona.

Rekord posiada strukturę używaną do reprezentowania układów różnego typu danych, tworzących pewne całości: Nr indeksu D123456 Miejscowość Poznań Kierunek studiów informatyka Pesel 88021601123 Imię Nazwisko Adam Kowalski Adres Rok NIP ul. Mickiewicza 22 m. 3 Semestr 3 Z Telefon 777-888-23-24 (61) 8765432

Typy rekordowe

Definicja typu rekordowego ma postać:

type identyfikator-typu = record lista-deklaracji pól; end;

gdzie lista-deklaracji pól ma postać:

lista identyfikatorów-pól : opis-typu;

Ostatnie pole może być polem wariantowym postaci:

case pole wyróżnikowe of wykaz-wariantów;

gdzie pole wyróżnikowe może być identyfikatorem typu porządkowego lub deklaracją zmiennej porządkowej wykaz wariantów ma postać:

lista-etykiet-wyboru : (lista-deklaracji pól)

Przykład:

type

data =

record

dzien : 1..31; //typ rekordowy //typ okrojony miesiac : 1..12; rok : integer;

end

; rodzaj = (ciezarowy, osobowy); pojazd =

record

marka, kolor : string[20]; //typ wyliczeniowy //typ rekordowy data_rejestracji : data;

case

typ : rodzaj

of

//pole wariantowe ciezarowy : (ladownosc : real); osobowy : (ilosc_osob : byte);

end

;

var

auto : pojazd; //deklaracja zmiennej rekordowej

Metody dostępu do pól rekordów

-

kwalifikowanie

za pomocą

selektora

, który ma postać:

identyfikator-rekordu.identyfikator-pola

gdzie identyfikator-rekordu to zmienna rekordowa Uwaga! Kropka oddziela nazwę zmiennej rekordowej od identyfikatora pola. -

instrukcja wiążąca

postaci:

with lista-zmiennych do instrukcja;

Umieszczenie zmiennej rekordowej na liście-zmiennych oznacza, że do pól tej zmiennej można odwoływać się wewnątrz instrukcji wiążącej za pomocą samych identyfikatorów pól. Identyfikatory te są traktowane w instrukcji wewnętrznej tak, jak zmienne.

Instrukcja

with

zagnieżdżonej z1, z2, ..., zn

do

instrukcja; jest równoważna instrukcji

with

z1

do with

z2

do

..............

with

zn

do

instrukcja;

Przykłady: auto.marka := ’Ford’; auto.data_rejestracji.dzien := 4; auto.data_rejestracji.miesiac := 6; auto.data_rejestracji.rok := 2007;

with

auto

do begin

marka := ’Ford’; data_rejestracji.dzien := 4; data_rejestracji.miesiac := 6; data_rejestracji.rok := 2007;

end

;

with

auto.data_rejestracji, auto

do begin

marka := ’Ford’; dzien := 4; miesiac := 6; rok := 2007;

end

;

Zbiory

Zbiory wraz z operacjami na nich zdefiniowanymi umożliwiają zapis obliczeń teoriomnogościowych.

Struktury te mają jednak zastosowanie w ograniczonym zakresie.

Każdy zbiór jest zbiorem wszystkich podzbiorów (tzw. zbiorem potęgowym), łącznie ze zbiorem pustym, typu bazowego. Typ bazowy musi być typem porządkowym o maksymalnie 256 elementach (liczby porządkowe elementów muszą być z przedziału 0-255).

Przykład: Typ bazowy = {a, b, c} Zbiór = {[ ], [a], [b], [c], [a,b], [a,c], [b,c], [a,b,c]}

Typy zbiorowe

Definicja typu zbiorowego ma postać:

type identyfikator-typu = set of typ porządkowy;

Zmienne tego typu zajmują od 1 do 32 bajtów.

Ilość zajmowanych bajtów = ord(max) div 8 – ord(min) div 8 + 1.

Konstruktor zbioru ma postać [ ].

Przykłady:

type

pory_roku = (wiosna, lato, jesien, zima); pory = litery =

set of

liczby =

set of set of

pory_roku; 1..8; ’a’..’z’; //typ wyliczeniowy //typ bazowy – pory_roku //typ bazowy – 1..8 //typ bazowy – ’a’..’z’

var

Z1 : pory; //1 bajt Z2 : liczby; Z3 : litery; Z1 := [ ]; Z1 := [lato, zima]; //2 bajty //4 bajty ord( ’z’)=122, ord(’a’)=97 //przykłady podstawień Z2 := [1, 2, 5]; Z3 := [’a’..’d’];

Wartości zmiennych typu zbiorowego

nie można wypisać

sposób przy pomocy instrukcji write, writeln.

w standardowy Na zmiennych zbiorowych można wykonywać operacje teoriomnogościowe.

Operatory teoriomnogościowe

operator ---------------------------------------------------------------------------------------------------- + – * suma zbiorów różnica zbiorów iloczyn zbiorów typ zbiorowy typ zbiorowy typ zbiorowy typ zbiorowy typ zbiorowy typ zbiorowy <= jest zawarty, jest podzbiorem typ zbiorowy Boolean >= = <>

in

operacja argumenty wynik zawiera, jest nadzbiorem typ zbiorowy Boolean równy różny typ zbiorowy typ zbiorowy Boolean Boolean należy, jest elementem typ bazowy, zbiór Boolean

Przykład:

var

z1, z2, zw :

set of

(a, b, c, d); w : Boolean;

begin

z1 := [a..c]; z2 := [a, b]; zw := z1+ z2; zw := z1+ [d]; zw := z1 – z2; zw := z1 – [c]; zw :=z1*z2; zw := z1+ [ ] w := a in z1; w := z1<= [a, c]

end

.

// zw=[a, b, c] // zw=[a, b, c, d] // zw=[c] // zw=[a, b] // zw=[a, b] // zw=z1 // w=true // w=false