Instrukcje sterujące Instrukcje sterujące służą zmianie liniowego porządku wykonania. Możemy zażądać wykonania jednej z dwóch alternatywnych dróg (instrukcją warunkową), czy też wykonania danego fragmentu wielokrotnie (pętlami).

Instrukcja warunkowa if Instrukcja if (z ang. jeżeli), służy wykonaniu lub ominięci pewnej parti programu przy określonych warunkach.

Składnia: if (warunek) // jeśli (warunek jest prawdziwy) inst1; // to wykonaj inst1;

Przy czym warunek musi być wyrażeniem typu bool (może to być np. porównanie, wykonanie jakiejś funkcji zwracającej bool, czy też wynik operacji logicznych przedstawionych w rozdziale o zmiennych logicznych).

Instrukcja inst1 to z kolei dowolna pojedyncza instrukcja, lub blok (który jak wiemy zachowuje się jak jedna instrukcja).

Instrukcja inst1 jest wykonywana jedynie jeśli warunek da w wyniku true.

Przykład:

int a = 15;

writefln("a wynosi ", a);

if (a < 10) // 1. warunek writefln("a jest mniejsze niż 10");

if (a < 100) // 2. warunek writefln("a jest mniejsze niż 100");

if ((a == 42) || (a == 15)) // 3. warunek writefln("a jest jedna z odpowiedzi");

Fragment ten da w wyniku: a wynosi 15 a jest mniejsze niż 100 a jest jedna z odpowiedzi

ponieważ pierwszy warunek jest fałszywy: a < 10, czyli 15 < 10, jest fałszem (false); a drugi warunek jest prawdziwy (15 jest mniejsze 100); trzeci warunek też jest prawdziwy (a jest równe 42 lub 15, w tym przypadku 15).

Jak widać w zależności jaka jest wartość zmiennej a, przed instrukcjami warunkowymi, wykonują się różne instrukcje. Dzięki temu możemy obsłużyć różne sytuacje w różny sposób.

Pomocne jest również słowo kluczowe else (ang. inaczej, w przeciwnym razie)

if (warunek) // jeśli (warunek jest prawdziwy) ints1; // wykonaj inst1; else // w przeciwnym wypadku inst2; // wykonaj inst2;

Instrukcja inst1 wykona się jeśli warunek jest prawdziwy, natomiast inst2 jeśli warunek jest nie prawdziwy. Tylko jedna z dwóch instrukcji się wykona.

Na przykład.

int b = 61;

if (b < 50) writefln("b jest mniejsze od 50"); else writefln("b nie jest mniejsze od 50");

da w wyniku: b nie jest mniejsze od 50

Warto przypomnieć tutaj o białych znakach, i zaznaczyć, że format tych instrukcji, którą tutaj zaprezentowano jest jedną z wielu, ale również jedną z bardziej przejrzystych. Można napisać:

if (b < 5) writefln("a mniejsze niz 5"); czy if(b < 5) writefln("a mniejsze niz 5"); czy if (b < 5) writefln("a mniejsze niz 5"); czy if (b < 5) writefln("a mniejsze niz 5"); czy if ( b < 5) writefln( "a mniejsze niz 5")

są dokładnie tym samym (choć nie nie zawsze jasne do przeczytania). Zwykle będziemy stosować przejrzystą formę pokazaną, na początku rozdziału, i to samo się czyni innych instrukcji sterujących podanych w dalszej części.

Bloki i konwencja Jak już wspomniano instrukcja inst1 (i inst2 również), może być blokiem instrukcji, np. int a = 5; int b; if (a == 5 || a == 7) { writefln("a jest równe:"); writefln("pięć"); writefln("albo"); writefln("siedem"); b = 2*a;

i podobnie z else: int a = 555; if (a < 10) writefln("a jest małe"); else { writefln("a jest duże"); writefln("zapewne bardzo duże");

czy też: int a = 5, b = 5; if (a == b) { writefln("a jest równe b"); writefln("a wiec ich rożnica to 0"); } else { writefln("a jest różne od b"); writefln("a wiec ich różnica nie jest 0");

Jak widać kiedy za instrukcją warunkową jest tylko jedna instrukcja, nie ma potrzeby tworzyć bloku:

bool test = true; if (test) writefln("prawda");

co czasami wygodnie zapisać w jednej linijce: bool test = true; if (test) writefln("prawda");

podobnie możemy skrócić if-else do dwóch linijek (zamiast ok. 4): bool test = false; if (test) writfln("prawda"); else writefln("fałsz");

czy nawet jednej bool test = false; if (test) writfln("prawda"); else writefln("fałsz");

jednak zaciemnie to kod, i może to prowadzić do pewnych nieporozumień (o czym za chwilę).

Z kolei jeśli mamy kilka instrukcji do wykonania to grupujemy ją w blok przy pomocy nawiasów klamrowych: if (test) { writefln("prawda"); writefln("test jest prawdą");

a nie: if (test) writefln("prawda"); writefln("inny napis"); // UWAGA: to jest poza if // wykona sie nie zaleznie od tego jakie jest test

ponieważ druga instrukcja writefln nie jest związana z instrukcją if - jest to instrukcja poza nią i najlepiej zapisać, ten fakt wyraźnie, używając wcięć:

if (test) writefln("prawda"); writefln("inny napis"); // poza if

W niniejszym podręczniku, będziemy używać klamr i jawnego bloku w zasadzie zawsze, nawet dla jednej instrukcji:

if (test) { writefln("prawda");

ponieważ, łatwo potem możemy dopisać nowe instrukcje, oraz wskazuje na "koniec" instrukcji warunkowej, nawiasem zamykającym.

Zagnieżdżanie Instrukcje warunkowe można zagnieżdżać (ponieważ inst1 i inst2 może być dowolną instrukcją). Można wtedy tworzyć skomplikowane rozgałęzienia w programie. Na przykład:

if (x < 10) { if (y < x) { writefln("y mniejsze niż x, a x mniejsze niż 10"); } else { writefln("y większe niż x, a x mniejsze niż 10");

} else { writefln("x wieksze od 10");

Tworzenie łańcuchów warunków: else if Czasami stosuje się taką konstrukcję w których w bloku else od razu umieszcza się zagnieżdżoną instrukcję warunkową if, w której bloku else można umieścić kolejne instrukcje. Załóżmy że x jest liczbą nie ujemną. Tworzy konstrukcje która wydrukuje opis tej liczb. Ciąg w rodzaju:

if (x == 0) { writefln("zero"); } else if (x == 1) { writefln("jeden"); } else if (x == 2) { writefln("dwa"); } else if (x < 10) { writefln("kilka"); } else if (x < 20) { writefln("kilkanaście"); } else if (x < 100) { writefln("kilkadziesiąt"); } else { writefln("dużo (powyżej sto)");

Konstrukcja taka pozwala na łatwe sprawdzenie kolejnych warunków, wykonanie tylko jednej gałęzi i nie sprawdzanie kolejnych warunków.

Instrukcja wybór z pośród wielu możliwości: switch W przypadku kiedy łańcuch else if zawiera testy równości pojedyńczej zmiennej, można wykorzystać insturkcję switch.

switch (x) { case 0: writefln("zero"); break; case 1: writefln("jeden"); break; case 2,3,4,5,6,7,8,9: writefln("kilka"); break; default: writefln("dużo (dziesięć lub więcej) lub liczba ujemna"); break;

Instrukcję case oznaczją etykiety do których trzeba przejść w wypadku zachodzenia odpowiedniej równości. Wartości za case muszą być stałe. Etykiety case są sprawdzane od góry (a przynajmniej tak powinno się wydawać programiście). W przypadku kiedy jedna z wartości przy case jest równa zmiennej x, program wykonuje wszystkie instrukcje za tą etykietą.

Instrukcja break (ang. przerwij, złam) jest tutaj wymagana ponieważ np. w wypadku gdyby ich nie było a zmienne x równała by się 1, to otrzymalibyśmy nastepujący wynik: jeden kilka dużo (dziesięć lub więcej) lub liczba ujemna

Czasami pominięcie instrukcji break jest potrzebne, ale są to specyficzne sytuację (tzw. fall-through, przejście, przeskok, spadek). Inne użycie instrukcji break znajdziemy w instrukcjach pętli.

Etykieta default pasuje do wszystkich wartości zmiennej x (analogicznie ostatnie else, w poprzednim paragrafie, jeśli w każdym case jest brake). Może więc służyć do obsługi nie standardowych sytuacji. Instrukcja break w default nie jest potrzebny, ponieważ i tak jest to ostatnia instrukcja. W przypadku kompilowania z włączonymi ostrzeżeniami etykieta default jest wymagana (można dodać tam instrukcję assert(0), jeśli jesteśmy pewni że program nigdy nie wykona tego bloku).

Oprócz liczb można również sprawdzać łańcuchy znaków, np.

switch (opcja) { case "-vv": debug = true; // bez break, bo -vv implikuje -v case "-v": verbose = true; break; case "-h": print_help(); break; default: writefln("Nieznana opcja"); exit(1); assert(0);

Pętla dopóki: while Pętle są chyba najważniejszym składnikiem programowania imperatywnego i służą temu co komputery robią najlepiej - powtarzaniu wielokrotnie podobnych instrukcji.

Załóżmy, że chcemy dodać liczby od 1 do 10. Następujący kod będzie marnotrawstwem możliwości komputera: int suma = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;

Kod taki będzie tym trudny do napisania, trudny do rozszerzenia oraz zapewne zapomnimy jakiejś liczby, np. jeśli zechcemy policzyć sumę liczb od 1 do 100.

Aby zrobić to sensowniej użyjemy pętli while (ang. dopóki):

while (test) instr;

Instrukcja instr jest wykonywana wielokrotnie dopóki test jest prawdą. Jeśli test jest fałszem instrukcja kończy swoje wykonywanie. Warunek jest sprawdzany tylko przed każdym wykonaniem instrukcji instr.

Do naszego celu użyjemy w takim razie następującej konstrukcji:

int suma = 0; // początkowa wartość sumy int i = 1; // obecnie dodawany składnik while (i <= 10) { // sprawdź czy zakończyć pętle suma += i; // dodaj ten składnik, pamiętaj że jest to równoważne suma = suma + i; i++; // zwiększ składnik o 1 i przejdź do następnego cyklu, tzn. i = i + 1;

Po zakończeniu wykonywania tego fragmentu programu zmienna suma powinna zawierać wartość sumy, który możemy wykorzystać gdzieś dalej (na przykład wyświetlić). Sprawdź czy program poprawnie oblicza sumę liczb od 1 do 10, zmieniając warunek while oraz drukując wynik.

Aby lepiej zrozumieć działanie tego programu, prześledźmy pętlę krok po kroku, wstawiając dodatkowe instrukcje drukowania:

import std.stdio; void main() { int suma = 0; // początkowa wartość sumy int i = 1; // obecnie dodawany składnik while (i <= 10) { // sprawdź czy zakończyć pętle writefln("Aktualny składnik: ", i); suma += i; // dodaj ten składnik writefln("Aktualna podsuma: ", suma); i++; // zwiększ składnik o 1 dla następnego obiegu

writefln("Suma to: ", suma);

Program wyświetli: Aktualny składnik: 1 Aktualna podsuma: 1 Aktualny składnik: 2 Aktualna podsuma: 3 Aktualny składnik: 3 Aktualna podsuma: 6 Aktualny składnik: 4 Aktualna podsuma: 10 Aktualny składnik: 5 Aktualna podsuma: 15 Aktualny składnik: 6 Aktualna podsuma: 21 Aktualny składnik: 7 Aktualna podsuma: 28 Aktualny składnik: 8 Aktualna podsuma: 36 Aktualny składnik: 9 Aktualna podsuma: 45 Aktualny składnik: 10 Aktualna podsuma: 55 Suma to: 55

Pokazując w jaki sposób kolejno zmienia się wartość zmiennej i oraz suma. Ostateczny wynik zgadza się z znanym wzorem na sumę elementów szeregu arytmetycznego 1, 2, ... n, to jest suma = n*(n+1)/2.

Pętla do..while

Istnieje drugi typ pętli do, zwany do-while. W przeciwieństwie do zwykłej pętli warunek jej powtarzania sprawdza się na końcu.

do instr while (test);

Najpierw zostanie wykonana instrukcja instr, a następnie sprawdzony warunek test. Jeśli test będzie prawdą to pętla będzie powtarzana. Zauważ, że instrukcja instr będzie wykonana conajmniej raz.

Nasz przykład z sumowaniem możemy zapisać przy pomocy tej pętli:

int suma = 0; int i = 1; do { suma += i; i++; } while (i <= 10);

Wygląda bardzo podobnie. Aby zobaczyć różnice, zaużmy że chcemy wykonać sumę samych siódemek, dopóki nowa suma będzie mniejsza niż 100. Przy pomocy pętli do wykonamy to poprawnie tak:

int suma = 0; while (suma+7 < 100) { // sprawdzamy czy nowa suma będzie mniejsza od 100 suma += 7; // jeśli tak to dodajemy te 7

Suma ta powinna się wynieść 98, ponieważ suma 14*7=98, a już 15*7=105, tak więc dopiero po piętnastym przebiegu pętli nasz warunek stanie się fałszywy.

W przypadku pętli do..while, i przepisaniu naiwnie tego kodu do postaci: int suma = 0; do { suma += 7; } while (suma+7 < 100);

Pętla for Pętla for jest chyba najważniejsza pętlą, ponieważ używa się jej najłatwiej, oraz służy bardzo często do operowania na tablicach i ciągach liczb. for (init; test; incr) instr;

Należy to rozumieć w nastepujący sposób: 1. Wykonaj wyrażenie init (od ang. inicjalizacja) 2. Sprawdź czy wyrażenie test jest prawdziwe, jeśli nie to zakończ pętle 3. Wykonaj instrukcje instr 4. Wykonaj wyrażenie incr (o ang. increment, zwiększ, krok) 5. Przejdź do punktu 2