1. INSTRUKCJA SWITCH
W poprzedniej części kursu powiedzieliśmy sobie m.in. o instrukcji warunkowej if. Wyobraźmy sobie taką sytuację: użytkownik wpisuje cyfrę z zakresu 1÷10, a program ma wyświetlić odpowiedni napis (jeden z dziesięciu możliwych). Możemy oczywiście 10 razy skorzystać z instrukcji if - ale po co? Do dokonywania wyboru jednej możliwości z wielu służy przecież switch (tak na marginesie: zawsze można zastąpić switch instrukcją if, ale w niektórych sytuacjach jest to zwyczajna głupota i marnotrawstwo, dlatego myślę, że warto ją poznać). Instrukcja ta wygląda następująco: switch(zmienna). Zobaczmy przykład:
char znak;
cin >> znak; // wczytanie zmiennej typu char
switch(znak) // bedziemy sprawdzac zmienna znak
{
case 'a': // sprawdzamy, czy zmienna znak = 'a'
cout << "Alleluja!";
break; // o tym za chwile...
case 'b': // czy znak = 'b'
cout << "Banan!";
break;
case 'c': // czy znak = 'c'
cout << "Ciastko!";
break;
default: // jesli znak nie jest rowny 'a' ani 'b' ani 'c'
cout << "Cos innego!"
break;
}
Jak więc widzimy, instrukcja switch sprawdza, czy zmienna ma jedną z podanych wartości. Jesli tak, wykonywana jest instrukcja zawarta po: case spelniony_warunek:. Jeśli żaden z podanych warunków nie został spełniony, wykonywane jest default (podobne do else, prawda?).
Powiedzmy jeszcze coś o słowie break. Jest to polecenie przerywające instrukcję (nie tylko switch, ale też np. pętle - zajmiemy się nimi w dalszej części lekcji) - gdy wystąpi, instrukcja definitywnie się kończy. Zapewne zapytasz: a po co tutaj? Przecież jeśli zmienna znak jest np. równa 'a', to wiadomo, że nie jest równa 'b' ani niczemu innemu, więc chyba nie trzeba przerywać instrukcji - program nie wykona nic więcej, prawda? Otóż niestety nie. Jeśli warunek jest prawdziwy, to nasz program wykonałby wszystkie instrukcje (bez sprawdzania warunku!) aż do wystąpienia słowa break (taka jest konstrukcja switch i nic na to nie poradzimy). Jeśli jest to trochę niezrozumiałe, oto przykład:
switch(znak) // bedziemy sprawdzac zmienna znak
{
case 'a': // sprawdzamy, czy zmienna znak = 'a'
cout << "Alleluja!";
case 'b': // czy znak = 'b'
cout << "Banan!";
case 'c': // czy znak = 'c'
cout << "Ciastko!";
default: // jesli znak nie jest rowny 'a' ani 'b' ani 'c'
cout << "Cos innego!"
break;
}
Jeśli zmienna znak miałaby wartość np. 'b', to program wyświetliłby na ekranie coś takiego:
Banan!Ciastko!Cos innego!
Wykonałby bowiem polecenie zawarte po case 'b' i wszystkie inne poniżej (aż do wystąpienia break na końcu).
I jeszcze jeden przykład na koniec:
int liczba;
switch(liczba)
{
case 1:
liczba += 9;
cout << "Dodalem 9";
break;
case 2:
liczba += 8;
cout << "Dodalem 8";
break;
default:
liczba = 10;
cout << "Po prostu przypisalem 10";
break;
}
Do zapamiętania z rozdziału:
- instrukcja switch służy do sprawdzania wielu opcji (konstrukcja: switch(zmienna))
- break przerywa działanie instrukcji
Zadanie:
Napisz program - kalkulator. Ma on wczytywać 2 liczby oraz działanie do wykonania, a następnie wyświetlić na ekranie wynik. Do wyboru działania zaimplementuj (tzn. zastosuj ;-)) instrukcję switch. Program powinien być zabezpieczony przed dzieleniem przez 0.
2. PĘTLA FOR
Do czego służą pętle? Najprościej mówiąc - do wykonywania tych samych instrukcji więcej niż jeden raz. Jeśli chcemy np. zrobić program, który ma wczytać od całej klasy w szkole (ok. 30 osób) dane osobowe, to nie musimy 30 razy wypisywać tej samej instrukcji - robimy pętelkę i po sprawie. Zasadniczo w C++ istnieją 3 rodzaje pętli: for, do-while oraz while.
Pętla for tym odróżnia się od dwóch pozostałych, że prawie zawsze ma z góry określoną liczbę powtórzeń. Teoretycznie jest też jedyną pętlą, która wymaga istnienia przynajmniej jednej zmiennej (licznika). Działa na zasadzie odliczania.
Jej konstrukcja jest następująca: for(licznik=wartosc_poczatkowa; warunek_wykonania; operacja_na_liczniku) { }
Podajemy pętli for 3 informacje: po pierwsze, od jakiej wartości ma zacząć liczyć; po drugie warunek, który dopóki jest spełniony, dopóty działa pętla; a po trzecie operację, jaką pętla wykonuje za każdym razem (na liczniku). Jeśli za bardzo zamotałem, zobaczmy przykład:
int licznik;
for(licznik = 0; licznik <= 10; licznik += 1) //petla for
{
cout << "Teraz licznik ma wartosc: " << licznik;
cout << endl; // robimy przerwe
}
<cpp>
Pętla ta wypisuje liczby naturalne od 0 do 10 (wypisuje każdą z tego zakresu, gdyż za każdym razem dodaje do licznika 1 i wyświetla jego wartość na ekranie).
Gdyby jednak ktokolwiek znający się na C++ zobaczył tę pętlę, usłyszelibyśmy gromki śmiech. Powód? Zamiast licznik += 1 mogliśmy (czytaj: absolutnie powinniśmy) napisać: licznik++. Efekt byłby dokładnie taki sam, a zapis jest dużo krótszy.
Jeśli kiedykolwiek czytałeś źródła jakiegoś programu, to spotkałeś się też zapewne z zapisem: ++licznik. Jest różnica? Owszem i to ogromna. Zapis licznik++ dodaje bowiem 1 do licznika PO każdorazowym wykonaniu pętli (jest to tzw. postinkrementacja), natomiast ++licznik PRZED (preinkrementacja).
Istnieje również analogiczny zapis licznik-- i --licznik (odejmowane jest wtedy 1 - jest to postdekrementacja i predekrementacja).
Dobrze, kończymy nudną teorię i piszemy:
<cpp>
int licznik, liczba;
cout << "Program wyswietli wszystkie liczby parzyste od 2 do... podaj liczbe: ";
cin >> liczba;
for(licznik = 2; licznik <= liczba; licznik += 2)
{
cout << licznik << endl;
}
Korzystamy tutaj z prawa, że każda liczba parzysta powiększona o 2 jest również parzysta.
A teraz odliczanie:
int licznik;
for(licznik = 10; licznik >= 1; licznik--)
{
cout << "Start rakiety za: " << licznik << endl;
}
cout << "Rakieta wystartowala!"!!!;
Do zapamiętania z rozdziału:
- pętla for działa określoną ilość razy
- konstrukcja: for(ustawianie_licznika; warunek; operacja_na_liczniku)
- zapis licznik++ jest równoważny zapisowi licznik += 1
Zadanie:
1. Napisz program, który wczytuje liczbę naturalną n, a następnie wyświetla na ekranie informację, ile jest wszystkich liczb podzielnych przez 3 z zakresu: od 0 do n.
2. Napisz program, który liczy silnię wczytanej liczby naturalnej n (n!). (Silnia liczby n to iloczyn wszystkich liczb całkowitych z zakresu 0 ÷ n.)
3. PĘTLE WHILE ORAZ DO - WHILE
Działanie tych pętli opiera się na bardzo prostej zasadzie - powtarzaj instrukcje zawarte w pętli dopóki warunek będzie spełniony. Ich konstrukcje to: while(warunek) { } oraz do { } while(warunek). Przykład:
char znak;
while(znak != 'a')
{
cout << endl << "Wpisz 'a', bo petla nie przestanie dzialac: ";
cin >> znak;
}
do
{
cout << endl << "Wpisz 'a', bo petla nie przestanie dzialac: ";
cin >> znak;
} while(znak != 'a');
Zauważmy pewną kolosalną różnicę pomiędzy tymi pętlami - pętla do - while zostanie wykonana przynajmniej 1 raz (warunek jest sprawdzany na końcu), natomiast while może nie zostać wykonana wcale (warunek jest sprawdzany na początku i jeśli będzie fałszywy, program po prostu pominie pętlę).
I jeszcze jeden przykład:
int liczba;
do
{
cout << "Podaj liczbe wieksza od 10";
cin >> liczba;
if (liczba == 28) break;
} while(liczba <= 10);
Pętla będzie wykonywana, dopóki wczytana liczba nie będzie większa od 10. W przypadku podania jednak liczby 28, pętla również zakończy pracę (zastosowaliśmy instrukcję break, poznaną w rozdziale o konstrukcji switch). Moglibyśmy zapisać nasz przykład również bez użycia break - przypomnijmy sobie wiadomości o operatorach logicznych. Wyglądałoby to mniej więcej tak:
do
{ // instrukcje
} while((liczba <= 10) || (liczba == 28)); /* dopoki liczba jest mniejsza lub rowna 10 LUB jest rowna 28 */
Dygresja dla zainteresowanych: podobnie jak w przypadku instrukcji if, pętle sprawdzają jedynie, czy wartość logiczna warunku jest różna od 0.
Do zapamiętania z rozdziału:
- konstrukcje: while(warunek) { } oraz do { } while(warunek)
- pętle while i do - while kończą działanie, gdy warunek nie zostanie spełniony
- pętla while może nie zostać nigdy wykonana, natomiast do - while zostanie wykonana przynajmniej raz
Zadanie:
Napisz program, który będzie wczytywał liczby dopóki dwie kolejne nie będą większe od 100 (na przykład dla wprowadzonych liczb: 34, 25, 16, 101, 150 pętla powinna się zakończyć). Program ma sprawdzać warunek po każdorazowym wprowadzeniu liczby.