[ Pobierz całość w formacie PDF ]
oprac. Robert Tomaszewski
>>>> Zadanie 1
Napisz program wczytujący od użytkownika kilka liczb do tablicy, a
następnie dokonujący cyklicznego przesunięcia w prawo lub w lewo.
Program pyta użytkownika ile liczb chce wpisać do tablicy, pobiera
od użytkownika te liczby i umieszcza w tablicy, pyta czy tablicę
przesunąć w lewo czy w prawo oraz o ile pozycji.
Przykład działania programu:
Tablica WE
1 2 3 4 5 6
Przesunięcie cykliczne w prawo o 3 pozycje
4 5 6 1 2 3
Tablica WE
1 2 3 4 5 6
Przesunięcie cykliczne w lewo o 4 pozycje
4 5 6 1 2 3
Zasada przesuwania cyklicznego: to co wychodzi z lewej strony
wchodzi od strony prawej i na odwrót. Powyższe przesuwanie bazuje
na przepisywaniu wartości spod odpowiednich indeksów tablicy. To
nie jest przesuwanie SHL ani SHR!
Przykład mechanizmu przesuwania cyklicznego elementów tablicy
"tab" o jedną pozycję w lewo przy założeniu, że cała tablica - od
najniższego do najwyższego indeksu - jest wypełniona elementami
(przesunięcie o większą liczbę pozycji to kilkukrotne wykonanie
sekwencji poniższych trzech instrukcji):
temp:=tab[Low(tab)];{zapamiętaj wartość spod najniższego indeksu}
for i:=Low(tab) to High(tab)-1 do tab[i]:=tab[i+1];
tab[High(tab)]:=temp;{wartość spod najwyższego indeksu zastąp
wartością spod najniższego}
Wstęp teoretyczny
Procedury i funkcje pozwalają grupować pewne fragmenty programu
(dowloną liczbę instrukcji) w postać podprogramu. Podprogram to
jakby mini program w programie głównym. Zarówno procedury jak i
funkcje mogą pobierać od programu głównego pewne wartości zwane
parametrami oraz zwracać do programu głównego wyniki swojego
działania (również w postaci parametrów). Różnica między funkcją a
procedurą polega na tym, że funkcja może dodatkowo zwrócić wynik
przez swoją nazwę.
Zmienne zadeklarowane wewnątrz procedury/funkcji są zmiennymi
lokalnymi i nie są "widziane" przez program główny. Jeżeli sekcja
"VAR" programu głównego znajduje się "powyżej" (przed) definicji
procedury/funkcji, to zmienne globalne (zadeklarowane w programie
głównym) będą widoczne w podprogramach o ile w podprogramach nie
zadeklarujemy zmiennych lokalnych o takich samych nazwach jak
globalne (te z sekcji "var" w programie głównym). Wówczas dla
podprogramu są ważniejsze jego zmienne lokalne i przesłonią one
identycznie nazwane zmienne programu głównego (innymi słowy
tracimy dostęp do przesłoniętych zmiennych
globalnych).
Jeżeli podprogram zmieni wartość zmiennej globalnej to zmiana ta
będzie obowiązywać po wyjściu z podprogramu (program główny oraz
inne podprogramy korzystające ze zmiennych globalnych będą takie
zmiany "widzieć").
Sposoby deklarowania parametrów:
const
- parametr nie może być zmieniany wewnątrz podprogramu
(const=stała)
var
- parametr może być zmieniany wewnątrz podprogramu a zmiany
będą widoczne po wykonaniu podprogramu w programie głównym
brak słowa kluczowego przed parametrem - parametr może być
zmieniany wewnątrz podprogramu ALE zmiany NIE BĘDA WIDOCZNE po
wykonaniu podprogramu w programie głównym
Przykład procedury obliczającej obwód koła:
var {globalna sekcja zmiennych}
x, y: Real;
{poniższa linia to nagłówek procedury}
procedure obwod (const r: real; var wynik: real); {w definicji parametry są
formalne}
const {lokalna sekcja stałych}
pi = 3.14;
begin {tzw. ciało podprogramu}
wynik:=2*pi*r; {instrukcje podprogramu, tutaj tylko jedna}
end; {koniec ciała podprogramu}
begin {program główny}
writeln('Podaj promień koła: ');
readln(x);
obwod(x,y);{przy wywołaniu 'zamieniane' są parametry formalne na aktualne: r
-> x, wynik -> y}
{wówczas to co było zadeklarowane wewnątrz podprogramu jako 'r' będzie
traktowane jak zmienna 'x', a 'wynik' - jak 'y'}
writeln('Obwod wynosi: ',y);
end.
Przykład funkcji obliczającej obwód koła:
var
x: Word;
y: Real;
{poniższa linia to nagłówek funkcji}
function obwod (const r: word): real; {funkcja zwraca wartość typu real}
const
pi = 3.14;
begin
obwod:=2*pi*r;
end;
begin
writeln('Podaj promień koła: ');
readln(x);
y:=obwod(x);{przy wywołaniu zamieniamy parametr formalny na aktualny: 'r' ->
'x'}
writeln('Obwod wynosi: ',y);
{w przypadku używania funkcji, jeśli nie zależy nam na zapamiętaniu jej
rezultatu w zmiennej globalnej - u nas jest to 'y' - można powyższe dwie
instrukcje zastąpić jedną w postaci: writeln('Obwod wynosi: ',obwod(x));}
end.
Przykład na rodzaje parametrów procedury/funkcji:
var
a, b, c: Word;
procedure parametry (const p1: Word; var p2: Word; p3: Word);
begin
p1:=p1+2;{źle - p1 jest 'const'!}
p2:=p2+2;{OK - zmiana będzie widoczna w głównym programie}
p3:=p3+2;{OK - ale zmiana nie zostanie utrwalona w głównym programie}
end;
begin
a:=1;
b:=1;
c:=1;
parametry(a,b,c);
writeln(a:3,b:3,c:3);{wyświetli się: 1 3 1}
parametry(b,c,a);
writeln(a:3,b:3,c:3);{wyświetli się: 3 3 1 - zastanów się dlaczego}
end.
UWAGI KOŃCOWE
Jeżeli zadeklarowano 3 parametry formalne to wywołując podprogram
musimy również wstawić 3 parametry aktualne. Kolejność
podstawiania ma znaczenie w tym sensie, że parametr formalny i
aktualny muszą być zgodnych typów.
Przykład:
type
TTab = array[0..3] of Byte;
var
napis: String[20];
liczba: Real;
tablica: TTab;
procedure przykladowa (var a: Real; b: String[20]; c: TTab);
begin
...
end;
begin
...
przykladowa(napis,liczba,tablica);{ŹLE! bo typy "a" i "napis" są niezgodne,
tak samo "b" i "liczba"}
przykladowa(liczba,napis);{ŹLE! bo zabrakło jednego z parametrów - "c"}
przykladowa(liczba,napis,tablica);{DOBRZE! wszystko się zgadza}
end.
>>>> Zadanie 1
Napisz program wykonujący cztery podstawowe działania arytmetyczne
(+,-,*,/), przy czym każde działanie ma być wykonywane w osobnej
procedurze/funkcji. Jedynie wynik danego działania musi być
wyświetlony w programie głównym.
Przykładowy nagłówek procedury dodającej: procedure Dodaj (const
a, b:Real; var wynik: Real);
Przykładowy nagłówek funkcji dodającej:
function Dodaj (const a,
b:Real): Real;
>>>> Zadanie 2
Napisz program obliczający średnią arytmetyczną z podanych przez
użytkownika liczb (dodatnie, ujemne, całkowite, rzeczywiste -
według własnego uznania). Użytkownik podaje ile liczb wprowadzi do
tablicy. Wprowadzanie liczb do tablicy odbywa się w programie
głównym, zaś obliczanie średniej w procedurze/funkcji. Tablicę
trzeba przekazać jako parametr do podprogramu.
Przykładowe nagłówki procedury/funkcji (tab-tablica liczb, ile-
liczba elementów tablicy):
procedure Srednia (const tab:TTablica; const ile:Word; var
wynik:Real);
function Srednia (const tab:TTablica; const ile:Word): Real;
>>>> Zadanie 3
Napisz program wyznaczający, ile spośród wprowadzonych przez
użytkownika wyrazów zaczyna się i kończy tym samym znakiem. Wyrazy
będą umieszczone w tablicy Stringów:
type
TabS = array[1..20] of String[20];
Użytkownik decyduje ile wyrazów poda (zabezpiecz tablicę przed
podaniem zbyt dużej liczby!), wyrazy wczytywane są w programie
głównym, zaś sprawdzenie ile spośród nich kończy się i zaczyna tym
samym znakiem musi odbywać się w podprogramie. Zwróć uwagę na
wielkość liter!
pierwszy znak: wyraz[1]
ostatni znak: wyraz[Length(wyraz)]
>>>> Zadanie domowe
Przerób zadania 2 i 3 z poprzednich ćwiczeń (instrukcja Z4.txt) na
rozwiązanie za pomocą procedury lub funkcji.
Wskazówki - w zadaniu 2 uzasadnione jest użycie funkcji
bezparametrowej zawierającej pętlę i zwracającej wynik przez swoją
nazwę. Zadanie 3 można rozwiązać wykorzystując procedurę z jednym
parametrem typu "var" (dlaczego?) przekazującym i zwracającym z
podprogramu odwracaną tablicę. Wczytanie tablicy oraz jej
wyświetlanie powinno się odbywać w programie głównym a nie w
procedurze!
Przeróbka zadania 4 na procedurę wymaga podania co najmniej 2-ch
parametrów: pierwszej tablicy ('const', bo ona nie podlega
modyfikacjom a jedynie odczytywaniu) oraz drugiej ('var', bo do
niej będziemy coś zapisywać, czyli zmieniać jej zawartość). Dobrze
jest również przekazać jako parametr długość pierwszej tablicy
(np. 'const n:byte') oraz zwrócić otrzymaną w wyniku przepisywania
elementów długość drugiej z tablic (np. 'var m:byte').
[ Pobierz całość w formacie PDF ]
© 2009 Po zniszczeniu przeszłości przyszedł czas na budowanie przyszłości. - Ceske - Sjezdovky .cz. Design downloaded from free website templates