Pętle w Pascalu i ich porównanie

Co to jest pętla i do czego służy?

Pętla jest to instrukcja lub zestaw instrukcji do wykonania przez program pod określonym warunkiem. Jak sama nazwa wskazuje powtarza pewną czynność określoną ilość razy, działa dopóki warunek nie zostanie spełniony, bądź działa dopóki warunek jest. spełniany. Używamy jej przy czynnościach, które wymagają wielokrotnego powtarzania do określonego warunkiem momentu.



Jakie wyróżniamy rodzaje pętli?

W Pascalu są trzy rodzaje pętli: Repeat – Until, While – Do i For to do.
Każda pętla różni się kilkoma rzeczami, ale tak naprawdę robi to samo.

1. Pętla Repeat – Until

Budowa pętli REPEAT – UNTIL:

\"REPEAT (instrukcje – oddzielone średnikami) UNTIL (warunek) \" – (powtarzaj);


Po słowie \"REPEAT\" wpisujemy instrukcje jakie mają być wykonywane przez program. Warunek zakończenia pętli jest podany na końcu po słowie \"UNTIL\", co oznacza że w chwili spełnienia warunku pętla skończy pracę. Wykonywane są w tej pętli wszystkie instrukcje między słowami \"REPEAT\" i \"UNTIL\". Taka konstrukcja pętli powoduje, że nawet gdy chcemy, aby w pętli wykonywało się kilka instrukcji, to nie musimy używać instrukcji grupującej (czyli \"begin...end;\").

Na przykład napiszmy coś takiego: \"Witam cię po raz 1, witam cię po raz 2 ... \" i tak dalej, aż do załóżmy 100. Chcemy, aby program wypisał 100 razy ten sam tekst z ciągle zwiększającą się liczbą o jeden. W takim przypadku trzeba zastosować pętle:

Program witaj;
USES CRT;
VAR
licznik:longint;
BEGIN
clrscr;
licznik:=0;
REPEAT
licznik:=licznik+1;
writeln(\'Witam cie po raz \',licznik);
UNTIL licznik=100
readln;
END.

A teraz wyjaśnienie. Na początku zdeklarowaliśmy zmienną o nazwie \"licznik\".
Zaraz po \"BEGIN\" czyścimy cały ekran i zerujemy licznik (przypisujemy wartość 0). Zaczynamy pętle. Od tego momentu, zatem, wszystko będzie powtarzane. Licznik przyjmuje wartość \"licznik+1\". Licznik miał wartość 0, zatem 0+1 jest jeden.
Licznik, więc ma wartość 1. Program rozkazuje napisać tekst i wstawić wartość licznika. Pętla się kończy, program sprawdza czy warunek jest spełniony. Aby pętla się zakończyła, wartość licznika musi wynosić 100. Nasz licznik aktualnie ma wartość 1. Zatem warunek nie został spełniony - program wraca do słowa \"REPEAT\".
I znowu - licznik zwiększa swoją wartość o 1, czyli ma już 2. Rozkazuje napisać tekst i wstawić licznik. Sprawdza warunek - warunek nie jest spełniony - i znowu \"REPEAT\" Licznik podnosi swoją wartość do 3 i tak dalej. Pętla się zakończy gdy wartość licznika będzie równa 100. Gdy pętla się zakończy, program wykonuje dalsze instrukcje (w tym wypadku jest to \"READLN\"), po czym zakańcza pracę.



2. Pętla For to Do

Budowa pętli FOR to DO:

\"FOR zmienna:=wartość początkowa TO wartość końcowa DO instrukcja\" – (dla);

Pierwsze słowo \"FOR\" to słowo kluczowe sygnalizujące, że w tym miejscu będzie pętla. Po nim następuje od razu inicjacja zmiennej sterującej pętlą \"for\".
Każda pętla for ma swoją zmienną sterującą, czyli licznik wykonywanych pętli. Przedtem taką zmienną trzeba zadeklarować, musi to być zmienną całkowita.
Pętla \"for\" ma to do siebie, że w każdym cyklu jej wykonania zmienna sterująca zostaje automatycznie zwiększona o 1. Po wartości początkowej pętli stawiamy słowo kluczowe \"TO\" a po nim liczbę będącą ogranicznikiem pętli, czyli wartość końcową. Po ograniczniku stawiamy słowo kluczowe \"DO\" (ang. wykonuj) i następnie jedną instrukcję, która będzie wykonywana w pętli. Oczywiście może być ich parę połączonych w jednym bloku (instrukcja złożona) stosując po słowie \"DO\" BEGIN i END koniecznie ze średnikiem na końcu instrukcji. Możemy użyć pętli także do odliczania w dół przez wpisanie słowa DOWNTO zamiast TO, wtedy program będzie liczył „od końca”, a wartość początkowa będzie większa od końcowej, odwrotnie niż w przypadku odliczania „od początku”.



program petla1;
uses crt;
var a:byte;
begin
for a:=1 to 10 do
begin
write(\'PETLA\');
end;
end.

program petla2;
uses crt;
var a:byte;
begin
for a:=10 downto 1 do
begin
write(\'PETLA\');
end;
end.

A teraz wyjaśnienie. Najpierw deklarujemy zmienną \"a\" jako liczbę z zakresu
0-255 (czyli byte). Teraz od zmiennej \"a\" równej 1 do liczby 10 program zrobi to co jest na dole po słowie BEGIN, czyli napisze słowo \"PETLA\" i powtórzy to 10 razy (bo taki był ustalony granicznik pętli), a następnie zakończy go.

Te dwa powyższe programy różnią się tym, że pierwszy wypisuje \"PETLA\"
od 1 do 10, a drugi od 10 do 1. W tym drugim licznik na początku przyjmuje wartość 10 i schodzi do 1, w pierwszym jest na odwrót, efekt jest taki sam.



3. Pętla While – Do

Budowa pętli WHILE – DO:

\"WHILE (warunek) DO (instrukcja)\" – (dopóki);

Po słowie WHILE wpisujemy warunek, który jest najczęściej jakimś wyrażeniem logicznym, czyli zwracającym jedną z dwóch wartości: prawda lub fałsz.
Po słowie kluczowym DO wstawiamy instrukcje. Gdy jednak chcemy zastosować więcej komend, trzeba zastosować instrukcje złożoną (grupującą). Pętla jest wykonywana tak długo, jak jest spełniony warunek wykonywania pętli.

program ile;
uses crt;
var a:byte;
begin
write(\'Ile to 2+2? \');
readln(a);
while a=4 do
begin
writeln(\'Dobrze\');
end;
end.


A teraz wyjaśnienie. Deklarujemy zmienną \"a\" jako liczbę z zakresu 0-255 (byte)
Program wyświetla nam pytanie \"Ile to 2+2?\" . Po podaniu liczby program czyta naszą odpowiedź - to ważny moment w programie, a następnie porównuje z warunkiem. Jeśli odpowiedź czyli zmienna \"a\" będzie równa 4 wtedy program idzie dalej, jeśli nie będzie powtarzał pytanie aż do skutku. Tu następuje początek podprogramu, czyli tego co stanie się po wpisaniu prawidłowej odpowiedzi \"a\", u nas wyświetlenie tekstu \"Dobrze\" po czym koniec pętli, który musi być zakończony słowem END; (koniecznie ze średnikiem). Program ten będzie powtarzał pytanie: \"Ile to 2+2?\" tyle razy aż nie otrzyma odpowiedzi 4.


Co to są spójniki?


W Pascalu mamy też kilka spójników logicznych. Najważniejsze z nich to: spójnik \"i\" reprezentowany słowem \"AND\" oraz spójnik \"lub\" reprezentowany słowem \"OR\". Dzięki nim w pętlach możemy połączyć kilka warunków logicznych. Można na przykład stworzyć warunek: \"((a>10) and (a<100))\". Kolejne warunki można formułować dokładniej używając nawiasów. Przykładowy warunek jest spełniony, gdy a jest większe od 10 i jest jednocześnie mniejsze od 100. Sprawdzanie należenia liczby do przedziału to tylko przykładowe wykorzystanie spójników logicznych.

Jakie są różnice pomiędzy pętlami?

1. Pętla FOR to DO:
 Zmienna sterująca musi być w przypadku pętli for zadeklarowana na poziomie jej wywołania, a jej wartość po wyjściu z pętli nie jest określona. Jednocześnie przy pętli for kompilator automatycznie sprawdzi, czy wartości początek i koniec są w zakresie typu zmiennej, tzn. czy może je przyjąć – musi mieć ona typ całkowity.
 Zmienna sterująca może sterować tylko o 1 w przód lub o 1 wstecz.
 Stosujemy ją kiedy wiemy ile razy ma być ona wykonana (wart. pocz. i końcowa.).
 Pętla wystartuje co najmniej jeden raz, po czym zakończy działanie np. z powodu błędu wartości początkowej i końcowej.


2. Pętla WHILE – DO:
 Nie posiada zmiennej sterującej pętlą jak pętla For to Do.
 Warunek zostaje sprawdzony na początku, przeciwnie do pętli Repeat - Until.
 Pętla ta działa dopóki warunek w niej zawarty jest spełniany.
 Jeśli warunek nie jest spełniony to nie wystartuje ona w ogóle inaczej niż w przypadkach pozostałych pętli For to Do i Repeat – Until.
 Instrukcje do wykonania (po słowie Do) rozpoczynamy od słowa begin, kończąc je słowem end; (ze średnikiem).
 Stosujemy ją kiedy nie wiemy ile przejść ma ona wykonać.


3. Pętla REPEAT – UNTIL:
 Nie posiada zmiennej sterującej pętlą jak pętla For to Do.
 Warunek zostaje sprawdzony na końcu, przeciwnie do pętli While – Do.
 Pętla działa dopóki warunek w niej zawarty nie jest spełniony, po jego spełnieniu przestaje działać, czyli dokładnie na odwrót do pętli While – Do.
 Pętla wystartuje co najmniej jeden raz tak jak pętla For to Do.
 W pętli tej nie ma konieczności użycia begin...end; czyli inst. grupującej.
 Może mieć wiele instrukcji złożonych sekwencyjnie w jedną całość.
 Stosujemy ją kiedy nie wiemy ile przejść ma ona wykonać.
4. Przykłady:


program suma; 1
uses crt;
var i:integer;
s:real;
begin
clrscr;
s:=0;
for i:=1 to 100 do
s:=s+i;
writeln(\'suma=\',s:8:2);
readln;
end.




program suma; 2
uses crt;
var i,s:real;
begin
clrscr;
s:=0;
i:=1;
repeat
s:=s+i;
i:=i+1;
until i>100;
writeln(\'suma=\',s:6:2);
readln;
end.


program suma; 3
uses crt;
var i,s:real;
begin
clrscr;
s:=0;
i:=1;
while i<=100 do
begin
s:=s+i;
i:=i+1;
end;
writeln(\'suma=\',s:6:2);
readln;
end.


Powyższe programy obliczają sumę liczb od 1 do 100 z zastosowaniem trzech różnych pętli.
Na podstawie tych programów pokażę niektóre różnice wypisane we wcześniejszym pytaniu.

Program 1: Po wpisaniu modułu ekranowego deklaruję zmienną \"i\" oraz nasze \"s\" – czyli wynik końcowy. Rozpoczynamy program od wyczyszczenia ekranu. Następnie tworzymy sumę początkową czyli \"s\" staje się 0. Podajemy wartość początkową równą 1 i wartość końcową równą 100 (bo chcemy obliczyć sumę 1-100). Tworzymy nową sumę dodając starą sumę (czyli 0) do wartości początkowej zmiennej sterującej (czyli 1). Po zakończeniu pracy pętli program wyświetli naszą sumę \"s\" (zgodnie z formatem), zatrzyma ekran i zakończy pracę.

Program 2: Po wpisaniu modułu ekranowego deklaruję zmienną krokową \"i\" oraz nasze \"s\", czyli wynik końcowy. Rozpoczynamy program od wyczyszczenia ekranu. Następnie tworzymy sumę początkową czyli \"s\" staje się 0, po czym tak samo tworzymy zmienną krokową \"i\" z tym, że dajemy jej wartość 1 bo zaczynamy liczyć od 1. Po znaczniku początku pętli (słowo REPEAT) tworzymy instrukcje, nowe \"s\" staje się stare \"s\" plus \"i\" (czyli stara suma 0 plus i równe 1), następnie tworzymy nowe \"i\", które staje się stare \"i\" plus 1 (bo liczymy po kolei 1,2.. itd.). Na końcu pętli umieszczamy warunek który nasza zmienna \"i\" musi spełnić by pętla zakończyła działanie. Po zakończeniu pracy pętli program wyświetli naszą sumę \"s\" (zgodnie z formatem), zatrzyma ekran i zakończy pracę.

Program 3: Po wpisaniu modułu ekranowego deklaruję zmienną krokową \"i\" oraz nasze \"s\", czyli wynik końcowy. Rozpoczynamy program od wyczyszczenia ekranu. Następnie tworzymy sumę początkową czyli \"s\" staje się 0, po czym tak samo tworzymy zmienną krokową \"i\" z tym, że dajemy jej wartość 1 bo zaczynamy liczyć od 1. Pętle zaczynamy od postawienia zmiennej \"i\" warunku działania pętli (nie zakończenia jej jak w przypadku repeat) czyli \"i\" musi być co najwyżej równe 100 aby pętla raz jeszcze zadziałała i zakończyła pracę. Otwieramy instrukcje pętli tworząc: nowe \"s\" staje się stare \"s\" plus \"i\" (czyli stara suma 0 plus i równe 1), następnie tworzymy nowe \"i\", które staje się stare \"i\" plus 1 (bo liczymy po kolei 1,2.. itd.), po czym stawiamy zakończenie instrukcji pętli end; (ze średnikiem). Po zakończeniu pracy pętli program wyświetli naszą sumę \"s\" (zgodnie z formatem), zatrzyma ekran i zakończy pracę.