2 strony - Stefan Brock

Zmienne i ich typy
■
■
■
■
Zmienne to komórki pamięci przeznaczone na
przechowywanie „przedmiotów”.
„Komórka” (zmienna) może być albo pusta albo
zawierać jeden „przedmiot”.
Nie każdy przedmiot pasuje do każdej komórki
(dla samolotu potrzebny jest hangar, na samochód
wystarczy garaż, oddzielną komórkę mamy na
węgiel, oddzielną na drewno, oddzielną na motor).
Zbiór przedmiotów pasujących do komórki
określa typ tej komórki.
Typ zmiennej
Typ zmiennej określa, co może zawierać
określona zmienna
■ Poznaliśmy niektóre typy: integer, real
■
Typy zmiennych - Typ logiczny
■
■
■
■
■
■
■
■
■
■
■
■
■
■
boolean
logiczny
Operacje:
var
x, y, z:boolean;
begin
x:=true;
y:=false;
z := not x;
z:= x and y;
z:= x or y;
Z:=not y
write(x);
read(x);
■
Typ logiczny mają
wyniki wszelkich
porównań
x
1
x
0
Typy zmiennych - Typ znakowy
■
■
■
■
■
■
■
■
■
■
■
■
char
znak
Operacje:
var
x, y, z:char;
begin
x:=‘p’;
y:=Chr(Ord(x)-1);
czyli ‘o’
z:=Chr(Ord(‘A’)+3);
czyli ‘D’
((z>’c’) and
(z=‘H’)) or (y<=‘Z’)
write(x);
read(x);
■
■
■
■
■
Typ znakowy pozwala
na przechowywanie
pojedynczych znaków
kodu ASCII
Jeżeli x jest typu
znakowego, to
Ord(x) podaje numer
kodu ASCII
Jeżeli y jest typu
całkowitoliczbowego,
to
Chr(y) podaje znak
odpowiadający kodowi
y.
X - zawiera znak spacji
0
0
1
0
0
0
0
0
Typy zmiennych – Typ całkowitoliczbowy
■
■
■
■
■
■
■
■
■
■
■
■
■
Integer
mała liczba całk.
Operacje:
var x,y,z:integer;
begin
x:= 7; y:=$13
{hexa}
y:=x-1; z:=x+y;
z:=x*y;z=:x div y;
z:=x mod y;
((z>7) and (z==5))
or (y<=z)
write(x);
read(x);
Uwaga:23 div 7 ->3
23 mod 7 ->2
■
Typ całkowitoliczbowy imituje liczby
całkowite w określonym zakresie
X zawiera liczbę 7
0
0
0
0
0
0
0
0
214 213 212
0
0
0
0
0
24 23
1
1
1
22
21
20
Znak: 0 to +, 1 to 1
X= +(0*214+0*213+......+0*24 +0*23 +1*22 +1*21 +1*20)=
=+(1*4+1`*2+1*1)=+(4+2+1)=+7
Zakres wartości : -32767 - +32767
Typy zmiennych - Typ zmiennoprzecinkowy
■
■
■
■
■
■
■
■
■
Real
Operacje:
var x, y, z:real;
begin
x=7.56;
y=x-1.;z=x+y;
z=x*y;z=x/y;
■
((z>7.)and(z==.5))or(y<=z
)
write(x);
read(x);
■
■
Typ
zmiennoprzecinkowy
imituje liczby
rzeczywiste.
Reprezentuje je tylko z
określoną dokładnością i
w określonym zakresie
Podczas operacji
następuje zaokrąglanie
wyniku (przez to stale
rośnie błąd)
Typ zmiennoprzecinkowy – liczba rzeczywista
X zawiera liczbę typu real
mantysa
1
1
0
0
0
0
0
0
0
0
0
0
0
1
1
1
2-1 2-2 2-3
wykładnik
0
0
0
0
0
0
0
0
2-23
Znak liczby: 0 to +, 1 to 1
0
0
0
0
26 25 24
1
1
1
23 22
21
20
0
Znak wykładnika: 0 to +, 1 to 1
X= -(1*2-1+0*2-2+......+0*2-23 )*2+7
=-(1*0.5)*127=+-64
Inne proste typy
■
■
■
■
■
■
■
Kompilatory PASCALa zwykle wprowadzają inne
jeszcze proste typy zmiennych o poszerzonych lub
zawężonych zakresach wartości
W Turbo Pascalu mamy np..
szortint – liczba całkowita –127 - +127
Byte - – liczba całkowita –0 –255
Longint – długa liczba całkowita (32 bity ze
znakiem)
Word – całkowita 16 bitów bez znaku
Single, double, extended, comp – liczby
zmiennoprzecinkowe
Typy zmiennych użytkownika
Użytkownik może w Pascalu wprowadzić
swoje własne typy
■ Używa do tego deklaracji type przed
zmiennymi var
■
Typy zmiennych użytkownika: wyliczany
■
Typy wyliczane deklaruje się jako:
Type wyksztalcenie=(podstawowe,srednie,wyzsze
);
Symbole podstawowe, srednie, wyzsze stają
się stałymi typu wyksztalcenie
■ Zmiennne tego typu deklarujemy jako
■
Var wyk1 : wyksztalcenie;
Typy zmiennych użytkownika: wyliczany
Przykłady:
■ Ord(podstawowe) = 0
■ Ord(srednie) = 1
■ Pred(srednie)=podstawowe
■ Succ(srednie)=wyzsze
■ Uwaga: funkcje Ord, Pred i Succ są
zdefiniowane także dla typów
całkowitoliczbowych oraz char i boolean.
■
Typy zmiennych użytkownika: zakresowy
Użytkownik dla typów porządkowych
(tych, dla których zdefiniowane jest Ord,
Succ i Pred) może wprowadzić nowe typy
będące ich pozakresami np..
■ Type XXwiek = 1901..2000;
■ Type wyknizsze = podstawowe..srednie;
■
Kontrola typów
■
■
■
■
Poszczególne operacje dopuszczają jedynie pewne
typy argumentów.
Np.. Operator mod czy div stosuje się wyłącznie
dla liczb całkowitych, and or i not tylko dla
logicznych itd..
Niektóre operatory zachowyją się inaczej dla
różnych typów, np.. Operator + inaczej dodaje
liczby, a inaczej znaki.
Użycie operatorów dla niewłaściwych typów
danych spowoduje błąd kompilacji
Konwersja typów
■
■
■
■
Niektóre typy zmiennych ulegają automatycznej
zamianie. Np.. Integer na real.
Dlatego np.. Można dodać liczbę real i integer, w
wyniku czego otrzymamy liczbę real.
W innych trzeba wymuszać konwersję
Np.. Trunc(lrzeczyw) oraz Round(lrzecz)
zamienia liczbę rzeczywistą na całkowitą
Tablica
Tablice używa się do reprezentacji
mnogości komórek pamięci tego samego
typu („gdy zabraknie nam imion”) X
■ Var x:garaz;
■
■
Var y: array[1..4] of garaz;
Y[1]
Y[2]
Y[3]
Y[4]
Deklaracja tablicy
Deklaracja zmiennej będącej tablicą składa się z
elementów:
VAR nazwa_zmiennej : ARRAY [zakres] OF
typ_podstawowy;
■ Np.:
Var z : array[1..200] of real;
to tablica 200 liczb rzeczywistych o nazwach z[1],
z[2],...,z[200]
■ Wyrażenie [3] nazywamy INDEKSEM.
■
Deklaracja tablicy
■
UWAGA: zwykle wielkość tablicy jest rzeczą
umowną i przy kolejnym użyciu programu może
być potrzebna tablica większa lub mniejsza.
Dlatego zwykle w deklaracji nie stosuje się się
liczby (np.. 200) lecz wprowadza się stałą
pomocniczą
Const maks_z=200;
Var z : array[1..maks_z] of real;
Deklaracja tablicy
Czasami jest uzasadnione używanie tablic o
zakresie indeksów zaczynającym się nie od
1.
■ Var podatek:array[1992..2005] of real;
■
■
To tablica elementów o nazwach
podatek[1992], podatek[1993],...,
podatek[2005]
Typy tablicowe użytkownika
■
■
■
■
■
■
■
Czasem kilka tablic powinno mieć identyczną
strukturę
Najlepiej jest wtedy zadeklarować typ tablicowy
Type DaneZLat=array[1992..2005] of real;
Potem deklarujemy zmienne:
Var podatek: DaneZLat;
przychody:DaneZLat;
kosztyuzyskania: DaneZLat;
Programowanie z użyciem tablic
Programowanie z użyciem tablic wymaga
stosowania pętli.
■ ZADANIE
■ Wczytaj z klawiatury n liczb rzeczywitych,
przy czym od użytkownika należy pobrać
liczbę n.
■
Czytanie tablicy zmiennych
program czyttab;
uses Crt;
Const maksTab=10;
var n,j:integer;
tab:array[1..maxTab]
of real;
begin
read(n); {1}
for J:=1 to n do
{2,3,4}
begin
read(tab[J]); {5}
end;
End.
START
1
Wczytaj(n)
2
J:=1
NIE
J<=n
3
TAK
4
Wczytaj(tab[J])
5
J:=J+1
STOP
UWAGI
UWAGA:
■ Pracując z tablicami musimy strzec się używania
indeksów spoza zakresu
■ W powyższym programie, jeśli użytkownik poda
n większe od 10, wystąpi błąd podczas wykonania
programu.
■ Aby temu zapobiec należy:
– Ostrzegać użytkownika, z jakiego zakresu ma podać
wartości
– Stosować nadzwyczajne zakończenie programu, jeśli
użytkownik naruszy dopuszczalny zakres
Czytanie tablicy zmiennych
START
1
Wczytaj(n)
TAK
n>maksTab
2
NIE
3
STOP
J:=1
NIE
J<=n
4
TAK
5
Wczytaj(tab[J])
6
J:=J+1
program czyttab2;
uses Crt;
Const maksTab=10;
var n,j:integer;
tab:array[1..maxTab]
of real;
begin
read(n); {1}
if n > maksTab then
Halt;
for J:=1 to n do
begin
read(tab[J]);
end;
End.
STOP
Czytanie i pisanie tablicy zmiennych
START
1
Wczytaj(n)
2
J:=1
NIE
J<=n
3
TAK
Wczytaj(tab[J]) 7
J:=J+1
4
5
6
NIE
J<=n
8
TAK
9
Wypisz(tab[J])
10
J:=J+1
program czytpisz ;
uses Crt;
Const maksTab=10;
var n,j:integer;
tab:array
[1..maksTab]
of real;
begin
Wypisz(‘UWAG
read(n);
A: piszę’)
for
J:=1 to n do
J:=1
read(tab[J]);
writeln(‘UWAGA:
piszę’);
for J:=1 to n do
writeln(tab[J]);
STOP
End.
Zadanie
■
Obliczyć średnia z wczytanych liczb
ANALIZA
■
Średnia to suma wartości podzielona przez
liczbę wartości
Średnia tablicy zmiennych
START
1
Wczytaj(n)
2
J:=1
NIE
J<=n
3
TAK
Wczytaj(tab[J])
6
J:=J+1
7
4
5
J:=1
Suma:=0
NIE
J<=n
8
11
TAK
9
Suma:=Suma+tab[J]
10
J:=J+1
12
STOP
Sred:=Suma/n
Wypisz(Sred)
Średnia tablicy zmiennych - PROGRAM
program srednia ;
uses Crt;
Const maksTab=10;
var n,j:integer;
tab:array[1..maxTab] of real;
suma, sred : real;
begin
read(n);
for J:=1 to n do
read(tab[J]);
suma:=0;
for J:=1 to n do
Suma:=Suma+tab[J];
Sred := Suma / n;
writeln(Sred);
End.
Zadanie
■
Znajdź maksymalny element wczytanej tablicy
■
ANALIZA
W pierwszym przybliżeniu za maksymum
przyjmiemy pierwszy element tablicy.
Jeśli którykolwiek z kolejnych elementów jest
większy od zakładanego maksymy, podstawiamy
maksymum tym elementem
■
■
35
30
25
20
15
10
5
0
Sty
Lut
Mar
Kw i
Maj
Cze
START
Maksimum
1
Wczytaj(n)
2
J:=1
NIE
J<=n
3
TAK
Wczytaj(tab[J])
6
J:=J+1
7
4
5
8
TAK
0
J<=n
NIE
TAK
MX<tab[J] NIE
9
MX:=tab[J]
11
J:=2
MX:=tab[1]
J:=J+1
12
Wypisz(MX)
STOP
Maksymum - Program
program maksymym ;
uses Crt;
Const maksTab=10;
var n,j:integer;
tab:array[1..maksTab] of real;
MX : real;
begin
read(n);
for J:=1 to n do
read(tab[J]);
MX:-tab[1];
for J:=2 to n do
if MX < tab[J] then MX:=tab[J];
writeln(‘Maksymum wynosi’);
writeln(MX);
End.
Zadanie
■
Znajdź wszystkie liczby pierwsze w
zakresie 2 – 5000
Analiza
■ Można wypisać wszystkie liczby od 2 do
5000, a następnie wykreślić wielokrotności
liczb pierwszych
■
Sito liczb pierwszych
program sito;
uses Crt;
const {Deklaracje stal`ych } MAX_N=5000;
var {Deklaracje zmiennych} n,j,k: Integer;
liczby: array [2..MAX_N] of Integer;{ tablica na liczby}
Ch : Char; { zmienna pomocnicza }
begin { Wlasciwy program}
Writeln('Liczby pierwsze do ? >>> '); Readln(n);
if (n>MAX_N) then Writeln('Za duza liczba ',n) else
begin {od else }
for j:=2 to n do liczby[j]:=j; { wstaw liczby 2-n do tablicy }
k:=2; while k*k<=n do
begin {cyklu}
j:=2*k; { usun` nadkrotnos`ci k }
while j<=n do begin liczby[j]:=0; j:=j+k end;
k:=k+1; { naste`pne k z liczby[k]!=0 }
while (liczby[k]=0) and (k<=n) do k:=k+1;
end; {cyklu}
for j:=2 to n do {druk liczb p.}if liczby[j]>0 then Write(' ',j);
end; {od else }
Writeln; Writeln(' KONIEC '); Ch:=ReadKey; end.
Tablice mogą być wielowymiarowe
■
Var y: array[1..2,1..4] of garaz;
Y[1,1]
Y[1, 2]
Y[1, 3]
Y[1, 4]
Y[2,1]
Y[2, 2]
Y[2, 3]
Y[2, 4]
Zadanie na laboratorium
Znaleźć sumę elementów wczytanej tablicy
■ Znaleźć maksymalny (minimalny) element
wczytanej tablicy
■ Powyższe najpierw dla tablic
jednowymiarowych, potem dla
dwuwymiarowych
■ Utworzyć tablicę zawierającą trójkąt Pascal
i wypisać trójkąt
■
Trójkąt Pascala:
■
■
■
■
■
■
■
■
■
■
■
W pierwszej kolumnie i na przekątnej ma jedynki
Elementy poniżej przekątnej są sumą elementu
wyżej i wyżej na lewo
1
11
121
1331
14641
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 ...................1
Struktura
■
■
■
■
Strukturalny typ danych stosujemy wtedy, gdy
chcemy opisać obiekt, którego kompletu cech nie
można wyrazić za pomocą pojedynczej liczby
Np..: pisząc godzinę 12.30 mamy na myśli dwa
składniki liczbowe: godzina i minuty
Pisząc datę 23.11.2001 mamy na myśli trzy
składniki liczbowe: dzień, miesiąc, rok.
Pisząc ułamek trzy czwarte mamy na myśli dwa
składniki liczbowe: licznik i mianownik
Deklaracja typu struktury:
■
■
■
Type data =
Record
dzien, miesiac,rok:integer;
end;
Type godzina=
Record
godz, min:integer;
end;
Type ulamek=
Record
licznik,mianownik:integer;
end;
Deklaracja zmiennej
Var dzis : data;
■ Var teraz : godzina;
■ Var wym : ulamek;
■
Dostęp do wartości
Read(teraz.godz); read(teraz.min);
■ Teraz.godz:=2; teraz.min:=43;
■ Writeln(teraz.godz); Writeln(teraz.min);
■
zadanie
■
Dodać dwa wektory trójwymiarowe
Analiza
■
■
■
Wektor trójwymiarowy można przedstawić jako
strukturę (rekord) o trzech składowych: x,y,z
Suma wektorów jest wektorem
Dodawanie dwóch wektorów oznacza dodanianie
do siebie odpowiednich składowych
Dodawanie wektorów
■
■
■
■
■
■
■
■
■
■
■
■
■
■
■
■
■
program Wektor3w;
type wek3w = record x,y,z:real; end;
var w1, w2, w3:wek3w;
begin
{Czytanie wektorów }
Writeln('Podaj 3 współrzędne pierwszego wektora:');
readln(w1.x, w1.y,w1.z);
Writeln('Podaj 3 współrzędne drugiego wektora:');
readln(w2.x, w2.y,w2.z);
{Dodawanie wektorów}
w3.x:=w1.x+w2.x;
w3.y:=w1.y+w2.y;
w3.z:=w1.z+w2.z;
{Prezentacja wyniku}
Writeln('Wektor sumy ma współrzędne');
Writeln('[',w3.x, ',', w3.y, ',' ,w3.z, ']' );
end.
zadanie
■
Obliczyć długość wektora trójwymiarowego
Analiza
Długość wektora jest liczbą
■ Jest po pierwiastek z sumy kwadratów
składowych
■
x2 + y2 + z 2
Obliczanie długości wektora
■
■
■
■
■
■
■
■
■
■
■
■
■
program Dlug3w;
type wek3w = record x,y,z:real; end;
var :wek3w;
dlug:real;
begin
{Czytanie wektora }
Writeln('Podaj 3 współrzędne pierwszego wektora:');
readln(w1.x, w1.y,w1.z);
{Obliczanie długości}
dlug:=sqrt(w1.x(w1.x+w1.y*w1.y+w1.z*w1.z);
{Prezentacja wyniku}
Writeln(‘Długość wektora wynosi‘, dlug);
end.
zadanie
■
Wczytaj i posortuj godziny
Analiza
■ Zadanie sortowania godzin niczym nie różni
się od sortowania liczb. Jedyne, co trzeba
uwzględnić to inny sposób porównywania
godzin, ich czytania i wypisywania
■ Można zastosować metodę EXCHANGE
SORT
Sortowanie godzin
■
■
■
■
■
■
■
■
■
■
■
■
■
■
■
■
■
program sortowgodz; {nazwa programu}
{ Program w je`zyku Pascal: sortowanie exchange sort liczb }
uses Crt;
{uz|yte biblioteki}
const {Deklaracje stal`ych }
MAX_N=5000;
type godzina= Record godz, min:integer; end;
Tablica = array [1..MAX_N] of godzina;
var {Deklaracje zmiennych}
n,j,k: Integer; { deklaracja zmiennej n oraz pomocniczej j i k}
liczby: Tablica; { tablica na liczby}
pomoc : godzina;
Ch : Char; { zmienna pomocnicza }
begin { Wlasciwy program}
{czytanie}
Writeln('ile godzin? >>> ');
Readln(n);
{ czeka na Twe dane }
if (n>MAX_N) then
Writeln('Za duza liczba ',n)
■
Sortowanie godzin cd.
■
■
■
■
■
■
■
■
■
■
■
■
■
■
else
begin
for j:=1 to n do {czytaj godziny }
begin Write('godzina[',j,']=');
Readln(liczby[j].godz,liczby[j].min);
end;
{Sortowanie}
for j:=1 to n-1 do
for k:=j+1 to n do
if (liczby[j].godz> liczby[k].godz)
or (( liczby[j].godz= liczby[k].godz)
and (liczby[j].min> liczby[k].min))
then
begin
pomoc:=liczby[k]; liczby[k]:=liczby[j]; liczby[j]:=pomoc;
end;
Sortowanie godzin cd.
■
■
■
■
■
■
{Prezentacja wyników}
Writeln(' Liczby w kolejności rosnącej');
for j:=1 to n do
Write(' ', liczby[j].godz:2,':',liczby[j].min:2);
end {do robienia czegikolwiek}
end.
Zadania na laboratorium
Wczytać i pomnożyć dwa ułamki
■ Obliczyć różnicę w minutach między dwoma
godzinami
■ Wczytać dwa wektory dwuwymiarowe
(składowe X,Y) i dodać je.
■ Wczytać serię dat i posortować je
■