Turbo Pascal: Tablice, procedury, funkcje

Język PASCAL – podstawy
Turbo Pascal:
Tablice, procedury, funkcje
Cele nauczania: Podstawowe zasady
programowania.
Osiągnięcia: Praktyczna znajomość
elementów programowania w języku Pascal
TABLICE
• Tablica jest strukturą danych zawierającą uporządkowany
zbiór obiektów tego samego typu.
Odpowiada pojęciu wektora czy macierzy.
• Tablice jednowymiarowe odpowiadają wektorom
a tablice 2-wymiarowe macierzom.
Elementy tablicy wskazuje się za pomocą indeksów.
• Dostęp do elementów uzyskuje się przez podanie nazwy
tablicy oraz w nawiasach [] wyrażenia określającego wartość
indeksu, np. t[5].
• Dla tablic 2-wymiarowych (zawierających wiersze i kolumny)
1-szy indeks odpowiada numerowi wiersza,
a 2-gi numerowi kolumny, np. a[4,5].
• Tablicę tworzymy przy pomocy słowa kluczowego array.
Definicja typu tablicowego
Definicja typu tablicowego ma postać:
type identtabl = array [zakresy_indeks] of typ_elementu;
• Dany identyfikator można następnie wykorzystać
w deklaracji var w sposób następujący:
var zmienna_tablicowa : identtabl;
Przykład:
type wector = array[1..30] of integer; {typ tablicowy}
var t1, t2: wektor; {tablice t1 i t2 typu wektor}
var t1, t2: array[1..30] of integer; {bezpośrednia deklaracja}
Bezpośrednia deklaracja tablicy
• Tablicę można też zdefiniować bezpośrednio
w deklaracji var
var zmienna = array[zakresy_indeksów] of typ_elem;
Przykłady:
var
test: arary[1..20, 1..10] of integer;
Wymiary: array[1..100] of real;
Liczlit: array[‘A’..’Z’] of integer;
Symbole: array[1..4] of char;
Przykłady programów z tablicami
Przykład 1
program Tabl1; {nadanie wartości elementom tablicy i wydruk}
var {deklaracja zmiennych}
i: integer;
tab: array[1..5] of integer; {definicja tablicy 1-wymiar}
Begin
for i:=1 to 5 do tab[i]:=10*i; {nadanie wartości
elementom tablicy}
for i:=1 to 5 do writeln(i,' ',test[i]); {wydruk wartości}
End.
Przykład 2 - tablica
program tabl_liczb_calk; {Program wczytuje do tablicy 5 liczb
całkowitych a następnie wyświetla}
var
Tab: array[1..5] of integer;
i: integer;
Begin
for i:=1 to 5 do
begin {początek for}
write('Podaj ', i, ' liczbę całkowita: '); readln(Tab[i])
end; {koniec for}
write('Podales nastepujace liczby: ');
for i:=1 to 5 do write(Tab[i], ', ');
Readln {czekanie na naciśniecie Enter}
End.
Znajdowanie elementu największego
• Dane: Zbiór n liczb.
• Wynik: Największy element w zbiorze.
• Kroki:
1. Przyjmij, że max to pierwszy element zbioru
2. Dla każdego kolejnego elementu x zbioru
wykonuj:
jeśli x>max, to za max przyjmij x
• Uwaga. Algorytm jest optymalny obliczeniowo
- złożoność n-1 (bo tyle mamy porównań)
Znajdowanie elementu największego - program
program Maksimum;
var
x: array[1..5] of real; max: real; i: integer;
begin
x[1]:=2.1; x[2]:=-4.15; x[3]:=3.25; x[4]:=2.1; x[5]:=0.1;
max:=x[1];
for i:=2 to 5 do if x[i]>max then max:=x[i];
writeln('Liczba największa to: ', max:0:2);
readln
end.
Program maksimum minimum
program Maks_min; {znajdowanie wartości maks. i minimalnej w tablicy}
var
x: array[1..5] of real; max, min: real; i: integer;
Begin
x[1]:=2.1; x[2]:=-4.15; x[3]:=3.25; x[4]:=2.1; x[5]:=0.1;
max:=x[1]; min:=x[1];
for i:=2 to 5 do
begin
if x[i]>max then max:=x[i];
if x[i]<min then min:=x[i];
end;
writeln('Liczba największa to: ', max:0:2);
writeln('Liczba najmniejsza to: ', min:0:2);
readln
End.
Procedury i funkcje
• Wiele problemów algorytmicznych (programistycznych)
łatwiej się rozwiązuje po podzieleniu ich
na podproblemy (podprogramy).
• Takimi podprogramami w języku Pascal są
procedury i funkcje.
• Dzięki procedurom i funkcjom program staje się
czytelniejszy i krótszy - często występujące czynności są
opatrzone nazwą i wywoływane w zależności
od potrzeb.
• Języki programowania umożliwiające tworzenie
programów z podprogramów, noszą nazwę języków
strukturalnych.
Procedury
• Składnia definicji procedury:
procedure nazwa (parametry);
deklaracje;
begin
{treść procedury}
end;
• Procedurę wywołujemy podając jej nazwę
i ewentualnie parametry wywołania
(w przypadku procedur z parametrami).
Przykłady – program bez procedury i z procedurą
program procedury1;
program bezprocedury;
var x,y,z : integer;
Begin
writeln ('Podaj trzy liczby całkowite');
read (x); read (y); read (z);
writeln ('Suma liczb: ',x+y+z);
writeln ('Podaj trzy liczby');
read (x); read (y); read (z);
writeln ('Roznica liczb: ', z-y-x);
End.
Powtarzanie tego samego schematu nie
jest właściwym wyborem.
Można temu zaradzić pisząc własną
procedurę, która nie tylko ułatwi nam
pracę, ale też skróci cały zapis.
Procedurę umieszczamy ją przed
programem głównym (przed Begin).
uses crt;
var x,y,z : integer;
{Procedura – bez parametrów}
procedure podaj_dane; {Nagłówek procedury}
begin
writeln ('Podaj trzy liczby');
read (x); {treść procedury}
read (y);
read (z)
end; {end ze średnikiem!!!}
{Program główny}
Begin
clrscr;
podaj_dane; {Procedura bez parametrów}
writeln ('x=',x,' y=',y, ' z=',z);
writeln ('Suma liczb ',x+y+z);
podaj_dane;
writeln ('x=',x,' y=',y, ' z=',z);
writeln ('Roznica liczb z-y-x=: ', z-y-x);
readln;
End.
Przykład. Program z procedurą
program Szlaczki;
var i : integer;
{ licznik wierszy }
procedure Szlaczek(Znak : char; Ile : integer);
begin
for i := 1 to Ile do { wypisz szlaczek }
write(Znak);
{ złożony z iluś znaków }
writeln
end;
begin
for i := 1 to 20 do { wypisz 20 szlaczków }
Szlaczek('*', i);
end.
program Rown_kwadratowe; {program rozwiazuje rownanie kwadratowe}
uses Crt; var a,b,c: real;
procedure start(tytul:string);
begin
ClrScr; Writeln('Autor: Jan Anonim'); Writeln(tytul); Writeln
end;
procedure liczPierwiastki(a,b,c: real);
var delta: real;
begin
Write('Rownanie '); delta:=b*b-4*a*c;
if delta<0 then Writeln('nie ma pierwiastkow.')
else if delta=0 then Writeln('ma jeden pierwiastek x1=',-b/(2*a):8:2)
else {if delta >0}
begin
Writeln('ma dwa pierwiastki:');
Writeln('x1=',(-b-Sqrt(delta))/(2*a):8:2);
Writeln('x2=',(-b+Sqrt(delta))/(2*a):8:2)
end {delta>0}
end;
procedure czytajDane(var a,b,c: real);
begin
Write('Podaj wspolczynnik a: '); Readln(a); Write('Podaj wspolczynnik b: '); Readln(b); Write('Podaj wspolczynnik c: '); Readln(c)
end;
procedure czekaj;
begin
Writeln; Write('Nacisnij klawisz Enter.'); Readln
end;
procedure blad(komunikat: string);
begin
Writeln; Write(komunikat); czekaj; Halt
end;
Begin {Wlasciwy program}
start('Pierwiastki rownania kwadratowego');
czytajDane(a,b,c);
if a=0 then blad('Zle dane.');
liczPierwiastki(a,b,c);
czekaj
End.
Korzystanie z procedur
• Przy dużych programach korzystanie z
procedur jest nieuniknione.
• Procedura, wygląda bardzo podobnie do
programu.
• Procedura rozpoczyna się słowem procedure
i kończy słowem end; (ze średnikiem).
• End. (z kropką) występuje tylko raz - na samym
końcu programu głównego.
Funkcja
• Funkcja to procedura, która może zwracać
jakąś wartość.
Przy wywołaniu funkcji należy użyć specjalnej
instrukcji przypisania:
Zmienna:=nazwa_funkcji(parametry_aktualne);
np. zmienna:=Moja_funkcja;
lub np. wypisać na ekranie wartość jaką zwraca
funkcja (czyli jaką oblicza):
write (Moja_funkcja);
Ogólna postać funkcji w jezyku Pascal, wywołanie funkcji
Ogólna postać funkcji:
function nazwa (lista parametrów formalnych): typ_wyniku;
{deklaracje-i-definicje-obiektów lokalnych: stałych,
zmiennych i typów}
begin
{instrukcje-realizujące-treść funkcji}
nazwa:=wynik
end;
Wywołanie funkcji:
zmienna:=nazwa(lista parametrów aktualnych);
Przykład programu z funkcją – Wartosc_bezwzgl
program Wartosc_Bezwzgl;
var x: real;
function bezw(a: real): real;
begin
if a>=0 then
bezw:=a
else
bezw:=-a
end;
Begin
write('Podaj liczbe: '); readln(x);
writeln('Wartosc bezwgledna liczby ', x:0:2, ' wynosi: ', bezw(x):0:2);
readln
End.
program Bisekcja;
{ Program rozwiązuje równania nieliniowe metodą bisekcji }
var
a, b, c : real;
{ granice przedziału i punkt podziału
eps : real; { dokładność }
function f(x:real):real;
begin
f := 1 - exp(sin(x)*cos(x));
end;
{ badana funkcja }
{ treść funkcji }
Begin
writeln('Program znajduje miejsce zerowe funkcji'); writeln('w przedziale [a; b]');
write('Podaj wartosc a: ');
{ wprowadź granice przedzialu } readln(a);
write('Podaj wartosc b: '); readln(b); write('Podaj dokladnosc: '); readln(eps);
repeat
c := (a + b)/2;
{ podziel przedział na pół }
if (f(a)*f(c)) < 0 then
b := c
{ funkcja ma przeciwne znaki w a i c }
else
a := c;
{ funkcja ma przeciwne znaki w b i c }
writeln(c);
until abs(f(c)) < eps;
{ badamy wartość bezwzględną! }
writeln('Miejsce zerowe: c = ',c:12:8);
readln;
End.