Kurs Pascal - III. Instrukcja warunkowa, grupująca, skoku, wyboru oraz pętle

[D.F.]

I. Wstęp

Witaj. Oto trzecia część kursu programowania w języku Pascal. W poprzednich częściach poznałeś pojęcia zmiennej, stałej, w jaki sposób można pobierać dane od użytkownika oraz je wyświetlać. Poznałeś też kilka użytecznych procedur. Ta część opisywała będzie różnego rodzaju instrukcje sterujące działaniem programu, takie jak instrukcja warunkowa, grupująca, skoku, wyboru oraz pętle.


II. Instrukcja warunkowa

Służy ona do sprawdzenia wartości logicznej jakiegoś wyrażenia, a następnie wykonania odpowiednich czynności zależnych od wyniku.
Instrukcja ta wygląda następująco:

 if warunek 
   then instrukcja 
     else inna instrukcja

Tłumacząc: Jeżeli warunek jest prawdziwy to wykonaj instrukcje, w przeciwnym wypadku, wykonaj inne instrukcje.

Najlepiej zobaczyć to na przykładzie, oto przykładowy program:

 program InstrukcjaWarunkowa;

 uses CRT;

 var
   Liczba : Integer;
 begin
   ClrScr();
   WriteLn('Witaj. Oto program sprawdzający czy dana liczba jest parzysta.');
   WriteLn('Podaj liczbę: ');
   ReadLn(Liczba);
   if Liczba mod 2 = 0
     then WriteLn('Podana liczba jest liczbą parzystą.')
       else WriteLn('Podana liczba jest liczbą nieparzystą.');
   ReadLn();
 end.

Program sprawdza czy podana przez użytkownika liczba jest parzysta, sprawdzając czy reszta z dzielenia tej liczby przez dwa jest równa zero.


Operatory logiczne

Operatorów logicznych często używa się przy instrukcjach warunkowych, dlatego teraz chciałbym je opisać. Operatory logiczne to and, or, not i xor. Są to po kolei: koniunkcja, alternatywa, zaprzeczenie i alternatywa wykluczająca. Oto przykładowy program korzystający z operatorów logicznych:

 program OperatoryLogiczne;

 uses CRT;

 var
   A, B, C : Integer;
 begin
   ClrScr();
   WriteLn('Podaj wartość dla A:');
   ReadLn(A);
   WriteLn('Podaj wartość dla B:');
   ReadLn(B);
   WriteLn('Podaj wartość dla C:');
   ReadLn(C);
   if (A = B) and (B = C)
     then WriteLn('Podane liczby są równe.')
   else if (A = B) or (B = C) or (A = C)
     then WriteLn('Dwie z podanych liczb są równe')
   else if not (A = B) and not (B = C)
     then WriteLn('Podane liczby są różne.');
   ReadLn();
 end.

Program pobiera od użytkownika trzy liczby, a następnie bada, czy są one sobie równe (podano trzy takie same liczby), lub czy przynajmniej dwie z nich są równe, czy jednak wszystkie liczby są różne od siebie. Widzimy tutaj też dość złożoną instrukcję warunkową, gdzie po sprawdzeniu warunku, następuje znów kolejne sprawdzenie. Jeszcze jedna rzecz. Ostatni warunek można zapisać przy pomocy operatora <>, który oznacza różne (nierówne), zamiast zaprzeczenia i operatora =, jednak zrobiłem tak z powodu, aby pokazać działanie operatora zaprzeczenia (not).


III. Instrukcja grupująca

Instrukcja ta służy do grupowania kilku instrukcji. Można powiedzieć, że instrukcje zawarte pomiędzy słowami kluczowymi begin i end; instrukcji grupującej są traktowane jako jedna instrukcja.

Zobaczmy to na przykładzie:

 program InstrukcjaGrupujaca;

 uses CRT;

 var
   Liczba : Integer;
 begin
   ClrScr();
   WriteLn('Program sprawdza czy liczba jest parzysta.');
   WriteLn('Podaj liczbę: ');
   ReadLn(Liczba);
   if Liczba mod 2 = 0 then
   begin
     WriteLn('Podałeś liczbę ',Liczba);
     WriteLn('Jest to liczba parzysta.');
   end else
   begin
     WriteLn('Podałeś liczbę ',Liczba);
     WriteLn('Jest to liczba nieparzysta.');
   end;
   ReadLn();
 end.

Powyższy program tak jak poprzedni sprawdza czy dana liczba jest parzysta, jednak w tym widzimy, że po sprawdzeniu warunku wykonywane jest dwukrotne wyświetlenie tekstu, zatem zostało ono objęte instrukcją grupującą. Instrukcji grupującej używa się też w innych sytuacjach (np. w pętlach). Jest ona pomocna, gdyż pozwala na wykonanie kilku instrukcji tam, gdzie składnia języka pozwala normalnie na wykonanie tylko jednej.


IV. Instrukcja skoku

Instrukcja wykonuje skok do określonego miejsca w programie poprzez zadeklarowaną wcześniej etykietę. Składnia tej instrukcji wygląda następująco: goto nazwa_etykiety

Przykładowy program:

 program InstrukcjaSkoku;

 uses CRT;

 var
   Znak : Char;
   label WyswietlenieTekstu; //deklaracja etykiety
 begin
   ClrScr();
   WyswietlenieTekstu: //miejsce zaznaczone etykietą
     WriteLn('Oto przykładowy tekst.');
     WriteLn('Czy chcesz wyświetlić ten tekst jeszcze raz? Jeśli tak, wpisz t');
     ReadLn(Znak);
     //sprawdzenie warunku, jeżeli prawda
     //to następuje skok do etykiety
     if Znak = 't' then goto WyswietlenieTekstu; x
 end.

Kod powyżej wyświetla przykładowy tekst, a następnie pyta, czy wyświetlić go jeszcze raz. Jeżeli tak, następuje skok do etykiety i ponowne wyświetlenie tekstu oraz pytania czy znów wyświetlić tekst.


V. Instrukcja wyboru

Instrukcja potrafi zastąpić użycie wielu instrukcji warunkowych. Jej składnia ma następującą postać:

case wyrażenie of
   pozycja1 : instrukcja1;
   pozycja2 : instrukcja2;
   pozycjaN : instrukcjaN;
   else inna_instrukcja;
 end;

Przykładowy program dla instrukcji wyboru:

 program InstrukcjaWyboru;

 uses CRT;

 var
   N : Byte;
 begin
   ClrScr();
   WriteLn('Menu główne (wpisz numer wybranej pozycji)');
   WriteLn('1. Pozycja numer jeden');
   WriteLn('2. Pozycja numer dwa');
   WriteLn('3. Pozycja numer trzy');
   WriteLn('4. Pozycja numer cztery');
   WriteLn('5. Pozycja numer pięć');
   WriteLn('6. Pozycja numer sześć');
   WriteLn('7. Pozycja numer siedem');
   WriteLn('8. Pozycja numer osiem');
   WriteLn('9. Pozycja numer dziewięć');
   ReadLn(N);
   case N of
     1 : begin
           WriteLn('Wybrałeś pozycję numer jeden.');
           WriteLn('Oto zawartość pozycji pierwszej.');
         end;
     2 : WriteLn('Wybrałeś pozycję numer dwa.');
     3 : WriteLn('Wybrałeś pozycję numer trzy.');
     4 : WriteLn('Wybrałeś pozycję numer cztery.');
     5 : WriteLn('Wybrałeś pozycję numer pięć.');
     6 : WriteLn('Wybrałeś pozycję numer sześć.');
     7 : WriteLn('Wybrałeś pozycję numer siedem.');
     8 : WriteLn('Wybrałeś pozycję numer osiem.');
     9 : WriteLn('Wybrałeś pozycję numer dziewięć.');
     else WriteLn('Nie ma takiej pozycji w menu.');
   end;
   ReadLn();
 end.

Powyższy program wyświetla na ekranie konsoli ponumerowaną listę. Następnie czeka na wybranie pozycji z listy poprzez wprowadzenie jej numeru. Dla każdego numeru wykonywane są inne instrukcje po dwukropku, a jeśli użytkownik wprowadzi numer, którego nie ma na liście wykona się instrukcja po słowie kluczowym else. W pozycji pierwszej widzimy także wcześniej omówioną instrukcję grupującą.


VI. Pętle

Pętle jak się można domyślić służą do wielokrotnego wykonywania jakiejś czynności. W języku Pascal mamy kilka rodzajów pętli, które po kolei postaram się opisać.
Pętla for

Pętla wykonuje jakąś instrukcję podaną ilość razy. Jej składnia wygląda: for licznik := wartość_początkowa to wartość_końcowa do instrukcja;

Oto przykładowy program, korzystający z pętli for:

 program PetlaFor;

 uses CRT;

 var
   I,M,N : Integer;
 begin
   ClrScr();
   WriteLn('Program wyświetlający liczby z danego przedziału.');
   WriteLn('Podaj liczbę początkową: ');
   ReadLn(M);
   WriteLn('Podaj liczbę końcową: ');
   ReadLn(N);
   if M < N then
   begin
     for I := M to N do
     begin
       if I = N
         then Write(I,'.')
           else Write(I,',');
     end;
   end;
   if M > N then
   begin
     for I := M downto N do
     begin
       if I = N
         then Write(I,'.')
           else Write(I,',');
     end;
   end;
   ReadLn();
 end.

Powyższy program wyświetla liczby z podanego przedziału. W pętli for widzimy też instrukcję warunkową, dzięki której pomiędzy liczbami jest przecinek, a po ostatniej wyświetlonej liczbie stawiany jest znak kropki.


Pętla repeat

Pętla for służyła do wykonania jakiejś czynności podaną z góry ilość razy. Jeżeli natomiast nie wiemy do końca ile powtórzeń ma być wykonanych to wygodnie użyć jest pętli repeat lub while. Pętla repeat wykonuje jakieś instrukcje, dopóki podany warunek jest prawdziwy.

Pętla repeat wygląda tak:

repeat instrukcje until warunek

Oto przykładowy program zadający użytkownikowi pytanie dopóki nie zostanie udzielona prawidłowa odpowiedź, lub użytkownik nie zamknie programu.

 program PetlaRepeat;

 uses CRT;

 var
   RokBitwy : Integer;
 begin
   ClrScr();
   repeat
     WriteLn('Witaj. Ten program zada Ci proste pytanie, na które musisz odpowiedzieć,');
     WriteLn('aby móc przejść dalej.');
     WriteLn('Bitwa pod Grunwaldem miała miejsce w roku:');
     ReadLn(RokBitwy);
     if RokBitwy <> 1410 then
     begin
       WriteLn('Zła odpowiedź. Spróbuj jeszcze raz.');
       ReadLn();
     end;
     ClrScr();
   until RokBitwy = 1410;
   WriteLn('Tak. Rok 1410 to jest prawidłowa odpowiedź.');
   ReadLn();
 end.

Pętli repeat używa się też często do zatrzymania działania programu do czasu wciśnięcia dowolnego klawisza. Wygląda to tak:

 program PetlaRepeat2;

 uses CRT;

 begin
   ClrScr();
   WriteLn('Witaj!');
   repeat until keypressed();
 end.

Instrukcje tą można rozumieć jako: "nie rób nic (,bo po słowie repeat nie ma żadnej instrukcji), dopóki nie zostanie wciśnięty jakiś klawisz", co w efekcie wprowadza program w pętlę do czasu wciśnięcia klawisza.


Pętla while

Pętla ta jest podobna do repeat, jednak różni się tym, że tutaj warunek sprawdzany jest na początku pętli.
Składnia pętli while przedstawia się następująco:

while warunek do instrukcja;

W pętli repeat, nawet, gdy warunek będzie nieprawdziwy, pętla wykona się tylko raz. W przypadku pętli while, pętla nie wykona się, ani razu.

Przykładowy program, wypisujący cyfry od zera do dziewięć. Wydaje się, że będzie to zrobione dwa razy, jednak pętla while nie wykona się w tym przypadku, ani razu, właśnie przez to, że sprawdza warunek na początku. Oto kod:

 program PetlaRepeatandWhile;

 uses CRT;

 var
   Counter : Integer;
 begin
   ClrScr();
   Counter := 0;
   repeat
     Write(Counter,' ');
     Counter := Counter + 1;
   until Counter = 10;

   //pętla poniżej nie wykona się, ani raz!
   Counter := 0;
   while Counter = 10 do
   begin
     WriteLn(Counter,' ');
     Counter := Counter + 1;
   end;
   ReadLn();
 end.

VII. Zakończenie

W tej części poznałeś sporo nowych instrukcji. Polecam Ci napisanie teraz kilku programów korzystających z tych instrukcji. Pamiętaj tylko, aby starać się nie kopiować kodu (nawet składni instrukcji), tylko pisać ręcznie, wtedy szybciej je zapamiętasz. Jednak, jeżeli zapomnisz jak wygląda dana instrukcja, zawsze możesz tutaj zerknąć.