Wolisz obejrzeć?
Olimpijskie Koło Informatyczne nagrywa swoje zajęcia i udostępnia je za darmo. Poniżej 5 odcinków o tym temacie — dobre uzupełnienie, jeśli wolisz obejrzeć niż przeczytać.
Co już umiesz i czego się nauczysz
Ta lekcja zakłada, że przerobiłeś lekcje Typy zmiennych i Input / Output: umiesz napisać szkielet programu, tworzyć zmienne, wczytywać dane przez cin, liczyć (także resztę z dzielenia %) i wypisywać wynik przez cout. Najważniejsza będzie dla nas część o typie bool: porównania ==, !=, <, >, <=, >= dają odpowiedź true albo false, a &&, || i ! łączą je w dłuższe warunki. Do tej pory umiałeś taką odpowiedź tylko wypisać jako 1 albo 0 — teraz program zacznie na jej podstawie decydować, co robić dalej.
Uczymy się tak samo jak poprzednio: przepisuj przykłady do swojego edytora i uruchamiaj je, przy pytaniach „Co wypisze program?” najpierw zgaduj, a dopiero potem sprawdzaj, i po każdej części rób ćwiczenia w sprawdzarce. Ta lekcja jest długa, ale nie musisz przerabiać jej za jednym razem — rób przerwy po kolejnych częściach. Na końcu czeka baza zadań na cały temat.
Pierwsza decyzja
if wykonuje kod tylko wtedy, gdy warunek jest spełniony, a else mówi, co zrobić w przeciwnym razie.
Warunki i wiele dróg
Porównania liczb, znaków i napisów, łańcuch else if i łączenie warunków przez &&, || i !.
Decyzje w praktyce
if w środku if, największa z trzech liczb, zamiana miejscami, ustawianie liczb w kolejności i liczenie.
Dwa skróty
switch i operator ?: — nie są konieczne, ale skracają kod i często zobaczysz je w cudzych rozwiązaniach.
TAK albo NIE. Przepisuj je z treści zadania co do litery: dla sprawdzarki TAK, Tak i tak to trzy różne odpowiedzi.
Mapa lekcji
if — zrób to tylko wtedy, gdy…
Wszystkie programy, które do tej pory napisałeś, działały jak przepis kucharski: linijka po linijce, od góry do dołu, zawsze tak samo. Bez względu na to, jakie dane dostały, wykonywały dokładnie te same instrukcje. Prawdziwe programy muszą jednak reagować na dane: bankomat wypłaci pieniądze tylko wtedy, gdy masz ich dość na koncie, a gra pokaże „Koniec gry” dopiero wtedy, gdy stracisz wszystkie życia.
Do podejmowania takich decyzji służy instrukcja if (po angielsku „jeżeli”). W zwykłym języku mówisz tak bez przerwy: „jeżeli pada deszcz, weź parasol”. W C++ zapisujesz to prawie tak samo:
if (warunek) {
// te instrukcje wykonają się tylko wtedy,
// gdy warunek jest prawdziwy (true)
}
warunek w nawiasie
Po słowie if, w okrągłych nawiasach, piszesz to, co sprawdzasz, np. wiek < 18. Znasz to z lekcji o typie bool: porównanie daje true albo false.
klamry { }
Między klamrami stoi kod, który wykona się tylko wtedy, gdy warunek jest prawdziwy. Gdy jest fałszywy, program przeskakuje całe klamry, jakby ich nie było.
wcięcie
Linijki w klamrach przesuwamy o 4 spacje w prawo. Kompilatorowi to obojętne, ale Ty od razu widzisz, co jest w środku if, a co już poza nim.
bez średnika
Po if (warunek) nie stawiasz średnika. Średnik w tym miejscu kończy if — dlaczego to groźne, zobaczysz kawałek niżej.
#include <iostream>
using namespace std;
int main() {
int wiek;
cin >> wiek;
cout << "Bilet do kina\n";
if (wiek < 18) {
cout << "Znizka dla ucznia!\n";
}
cout << "Milego seansu\n";
return 0;
}
Uruchomiliśmy ten sam program dwa razy, z różnymi danymi. Dla wieku 15 warunek wiek < 18 jest prawdziwy, więc program wszedł do klamer i wypisał zniżkę. Dla wieku 30 warunek jest fałszywy — program przeskoczył klamry i poszedł dalej. Pierwszy i ostatni napis pokazały się za każdym razem, bo stoją poza klamrami.
Tak wygląda ten program narysowany jako schemat. Program idzie z góry na dół, a przy warunku wybiera jedną z dwóch strzałek:
Prześledźmy program linijka po linijce
Najlepszy sposób, żeby zrozumieć if, to „wykonać” program w głowie, linijka po linijce, i zapisywać, co się dzieje. Oto ślad programu kino.cpp dla obu uruchomień:
| Linijka | wiek = 15 | wiek = 30 |
|---|---|---|
cin >> wiek; | wczytuje 15 | wczytuje 30 |
cout << "Bilet do kina\n"; | ✓ wypisuje | ✓ wypisuje |
if (wiek < 18) | 15 < 18 → true | 30 < 18 → false |
cout << "Znizka dla ucznia!\n"; | ✓ wypisuje | ✗ przeskakuje |
cout << "Milego seansu\n"; | ✓ wypisuje | ✓ wypisuje |
if, wykonuje się tylko wtedy, gdy warunek jest prawdziwy. To, co jest za klamrami, wykonuje się zawsze — tak jak w programach, które pisałeś do tej pory.
W klamrach może być wiele instrukcji
W klamrach możesz umieścić tyle instrukcji, ile chcesz — wypisywanie, obliczenia, zmianę zmiennych. Wszystkie wykonają się razem, gdy warunek jest prawdziwy, i wszystkie zostaną pominięte, gdy jest fałszywy:
int punkty;
cin >> punkty;
if (punkty >= 100) {
cout << "Rekord!\n";
cout << "Dostajesz odznake\n";
punkty = punkty + 50; // premia
}
cout << "Masz " << punkty << " pkt\n";
Od tej pory przykłady często będą fragmentami programu — bez #include i main, żeby było widać to, co najważniejsze. Gdy chcesz je uruchomić, wklej je do środka main, tak jak w kino.cpp.
if, który zmienia zmienną
Bardzo często if niczego nie wypisuje, tylko poprawia wartość zmiennej. Potem program wypisuje wynik tak samo jak zawsze. Pierwszy przykład: wartość bezwzględna, czyli liczba „bez minusa”. Jeśli liczba jest ujemna, zmieniamy jej znak, a jeśli nie jest — zostawiamy ją w spokoju.
int x;
cin >> x;
if (x < 0) {
x = -x; // -7 staje się 7
}
cout << x << "\n";
int cena;
cin >> cena;
if (cena > 100) {
cena -= 20; // rabat 20 zł
}
cout << "Do zaplaty: " << cena << " zl\n";
Zapis x = -x wygląda dziwnie, ale czytaj go od prawej: „weź x ze zmienionym znakiem i włóż z powrotem do x”. Dla x = −7 wychodzi −(−7) = 7. A cena -= 20 to skrót od cena = cena - 20, który znasz z lekcji o typach.
Bardzo przydatny jest też taki schemat: dzielenie z zaokrągleniem w górę. Na wycieczkę jedzie 50 osób, a autobus mieści 12. Dzielenie całkowite 50 / 12 daje 4, ale 4 autobusy pomieszczą tylko 48 osób — potrzebny jest piąty. Dodatkowy autobus jest potrzebny zawsze wtedy, gdy dzielenie nie wychodzi równo, czyli gdy reszta jest różna od zera:
int osoby, miejsca;
cin >> osoby >> miejsca;
int autobusy = osoby / miejsca;
if (osoby % miejsca != 0) {
autobusy++; // ktoś się nie zmieścił
}
cout << autobusy << "\n";
Kilka if-ów jeden po drugim
W programie może być wiele instrukcji if. Każda działa niezależnie: program dochodzi do niej, sprawdza jej warunek i albo wchodzi do klamer, albo je przeskakuje. Dlatego może się zdarzyć, że wykona się kilka z nich, jedna albo żadna:
int t;
cin >> t;
if (t < 0) {
cout << "Mroz - zaloz czapke\n";
}
if (t > 30) {
cout << "Upal - wez wode\n";
}
if (t % 2 == 0) {
cout << "Temperatura parzysta\n";
}
cout << "Temperatura: " << t << "\n";
Pułapka 1: średnik po if
Ten program ma błąd, którego bardzo trudno się dopatrzyć. Zmienna x to 3, więc napis nie powinien się pokazać — a jednak się pokazuje:
int x = 3;
if (x > 10); {
cout << "x jest duze\n";
}
cout << "koniec\n";
Winny jest średnik po nawiasie. Średnik kończy instrukcję, więc if (x > 10); znaczy: „jeżeli x jest większe od 10, nie rób nic”. Klamry, które stoją dalej, nie należą już do if — to zwykły blok kodu, który wykonuje się zawsze.
Zapamiętaj: po nawiasie z warunkiem od razu otwierasz klamrę, bez średnika.
Pułapka 2: if bez klamer
Klamry wolno pominąć, gdy w środku jest dokładnie jedna instrukcja: if (x < 0) x = -x;. Ale wtedy do if należy tylko ta jedna, najbliższa instrukcja — nawet jeśli wcięcie sugeruje coś innego:
int x = 5;
if (x > 10)
cout << "x jest duze\n";
cout << "naprawde duze!\n";
cout << "koniec\n";
Do if należy tylko pierwszy cout. Drugi, mimo wcięcia, stoi już poza nim i wykonuje się zawsze. Kompilator patrzy na klamry i średniki, a nie na spacje.
Rada na początek: zawsze pisz klamry, nawet przy jednej instrukcji. Kosztuje to dwa znaki, a oszczędza godzin szukania błędów.
Najpierw odpowiedz w myślach — prześledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.
int a = 7;
if (a > 5) {
cout << "A";
}
cout << "B";
Pokaż odpowiedź
a?int a = 3;
if (a > 5) {
cout << "A";
}
cout << "B";
Pokaż odpowiedź
n?int n = 10;
if (n % 2 == 0) {
n = n / 2;
}
cout << n;
Pokaż odpowiedź
int x = 4;
if (x > 2) {
x = x + 10;
}
if (x > 12) {
x = 0;
}
cout << x;
Pokaż odpowiedź
int x = 1;
if (x == 2); {
cout << "dwa";
}
cout << "!";
Pokaż odpowiedź
int k = 0;
if (k > 0)
cout << "plus";
cout << "koniec";
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
else — co zrobić w przeciwnym razie
Sam if mówi: „zrób to, jeżeli…”. Często jednak potrzebny jest też plan B: „jeżeli pada, weź parasol, a w przeciwnym razie weź okulary przeciwsłoneczne”. Do tego służy słowo else (po angielsku „w przeciwnym razie”). Stawiasz je zaraz za klamrą zamykającą if i dajesz mu własne klamry:
if (warunek) {
// wykona się, gdy warunek jest prawdziwy
} else {
// wykona się, gdy warunek jest fałszywy
}
Teraz program zawsze wykona dokładnie jedną z dwóch części: albo tę po if, albo tę po else. Nigdy obu naraz i nigdy żadnej. Najprostszy przykład to sprawdzenie, czy liczba jest parzysta:
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "PARZYSTA\n";
} else {
cout << "NIEPARZYSTA\n";
}
return 0;
}
Pamiętasz % z lekcji o typach? n % 2 to reszta z dzielenia przez 2: dla liczb parzystych wynosi 0, a dla nieparzystych nie. Warunek n % 2 == 0 zobaczysz jeszcze setki razy.
-7 % 2 to -1, a nie 1. Dlatego nieparzystość sprawdzaj przez n % 2 != 0 (albo po prostu else po n % 2 == 0), a nie przez n % 2 == 1 — ten drugi warunek dla −7 jest fałszywy!
TAK albo NIE — najczęstszy format odpowiedzi
W zadaniach olimpijskich bardzo często trzeba odpowiedzieć na pytanie: „wypisz TAK, jeśli …, a NIE w przeciwnym razie”. To jest dokładnie if … else. Na przykład: czy liczba dzieli się przez 3? Liczba dzieli się przez 3, gdy reszta z dzielenia przez 3 wynosi 0.
int n;
cin >> n;
if (n % 3 == 0) {
cout << "TAK\n";
} else {
cout << "NIE\n";
}
W obu gałęziach może być więcej instrukcji
Część po if i część po else nazywamy gałęziami. W każdej może być dowolnie dużo instrukcji. Przykład: masz w portfelu mam złotych i chcesz kupić coś za cena złotych.
int mam, cena;
cin >> mam >> cena;
if (mam >= cena) {
cout << "Kupujesz!\n";
cout << "Zostanie ci " << mam - cena << " zl\n";
} else {
cout << "Za malo pieniedzy\n";
cout << "Brakuje " << cena - mam << " zl\n";
}
Zwróć uwagę na warunek mam >= cena, a nie mam > cena. Gdy masz dokładnie tyle, ile kosztuje rzecz, też ją kupisz — i zostanie Ci 0 zł. Przy każdym warunku zastanów się, co ma się stać na granicy, czyli gdy obie strony są równe.
Gałęzie, które ustawiają zmienną
Tak jak sam if, gałęzie if … else mogą niczego nie wypisywać, tylko ustawiać wartość zmiennej. Oto większa z dwóch liczb:
int a, b;
cin >> a >> b;
int wieksza; // tworzymy ją PRZED if
if (a > b) {
wieksza = a;
} else {
wieksza = b;
}
cout << wieksza << "\n";
Co, gdy liczby są równe? Warunek 5 > 5 jest fałszywy, więc wykona się else i wieksza dostanie wartość b, czyli też 5. Wynik jest poprawny — warto jednak zawsze sprawdzić w głowie taki „remis”.
Pułapka: zmienna utworzona w klamrach znika za nimi
Dlaczego w poprzednim przykładzie zmienną wieksza utworzyliśmy przed if? Zobacz, co się stanie, gdy utworzysz ją w środku gałęzi:
int a, b;
cin >> a >> b;
if (a > b) {
int wieksza = a;
} else {
int wieksza = b;
}
cout << wieksza << "\n";
Program się nie skompiluje. Zmienna żyje tylko w klamrach, w których ją utworzyłeś. Gdy program wychodzi z klamer, zmienna znika — a w ostatniej linijce kompilator nie zna już żadnej wieksza.
Dlatego zmienną, której potrzebujesz po if, tworzysz przed nim, a w gałęziach tylko zmieniasz jej wartość.
Pułapka: else nie ma warunku
else znaczy „w każdym innym przypadku”, więc nie dopisuje się do niego warunku. Jeśli chcesz sprawdzić kolejny warunek, potrzebujesz else if — poznasz go w części 04.
int n;
cin >> n;
if (n > 0) {
cout << "dodatnia\n";
} else (n < 0) {
cout << "ujemna\n";
}
int n;
cin >> n;
if (n > 0) {
cout << "dodatnia\n";
} else {
cout << "niedodatnia\n";
}
Dwa osobne if-y to nie to samo co if … else
Mogłoby się wydawać, że else da się zastąpić drugim if z odwrotnym warunkiem. Często tak, ale nie zawsze! W grze kupujesz miecz za 10 monet. Masz 15 monet:
int monety;
cin >> monety;
if (monety >= 10) {
monety -= 10;
cout << "Kupiles miecz\n";
}
if (monety < 10) {
cout << "Nie stac cie na miecz\n";
}
int monety;
cin >> monety;
if (monety >= 10) {
monety -= 10;
cout << "Kupiles miecz\n";
} else {
cout << "Nie stac cie na miecz\n";
}
W wersji z dwoma if-ami pierwszy z nich zmienił monety z 15 na 5. Drugi if sprawdził swój warunek od nowa, już dla nowej wartości — i 5 < 10 okazało się prawdą. if … else sprawdza warunek tylko raz i wybiera jedną drogę, więc takiej niespodzianki nie ma.
Pamiętaj: z if … else wykonuje się zawsze dokładnie jedna gałąź.
int x = 4;
if (x > 4) {
cout << "A";
} else {
cout << "B";
}
Pokaż odpowiedź
int x = -3;
if (x % 2 == 0) {
cout << "P";
} else {
cout << "N";
}
Pokaż odpowiedź
cout << -7 % 2;
Pokaż odpowiedź
12. Co wypisze program?int n;
cin >> n;
if (n >= 10) {
n = n - 10;
} else {
n = n + 10;
}
cout << n;
Pokaż odpowiedź
int p = 8;
if (p > 5) {
p = 2;
} else {
p = 9;
}
if (p > 5) {
cout << "duzo";
} else {
cout << "malo";
}
Pokaż odpowiedź
if (a > b) {
int m = a;
} else {
int m = b;
}
cout << m;
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Z czego zbudować warunek
Warunek to wszystko, co daje odpowiedź true albo false. Najczęściej jest to porównanie. Sześć operatorów porównania znasz już z lekcji o typie bool — oto one jeszcze raz, tym razem w roli warunków w if:
| Zapis | Czyta się | Przykład warunku | Co sprawdza |
|---|---|---|---|
a == b | a równe b | if (odp == 42) | czy odpowiedź to dokładnie 42 |
a != b | a różne od b | if (n % 10 != 0) | czy liczba nie kończy się zerem |
a < b | a mniejsze od b | if (t < 0) | czy jest mróz |
a > b | a większe od b | if (wynik > rekord) | czy padł nowy rekord |
a <= b | a mniejsze lub równe b | if (waga <= 20) | czy bagaż mieści się w limicie |
a >= b | a większe lub równe b | if (wiek >= 18) | czy osoba jest pełnoletnia |
= czy ==? Najczęstszy błąd w całym C++
Pojedynczy znak = to przypisanie: „włóż tę wartość do zmiennej”. Podwójny == to pytanie: „czy te dwie rzeczy są równe?”. W warunku prawie zawsze chodzi o ==. Najgorsze jest to, że pomyłka zwykle się kompiluje — program po prostu działa źle:
int x = 3;
if (x = 5) {
cout << "x to piec\n";
}
cout << "x = " << x << "\n";
int x = 3;
if (x == 5) {
cout << "x to piec\n";
}
cout << "x = " << x << "\n";
Co się stało po lewej? x = 5 włożyło 5 do zmiennej x, a cały zapis ma wartość 5. Dla if każda liczba różna od zera jest prawdą, więc program wszedł do klamer. Do tego po cichu zepsuł zmienną: x było 3, a jest 5. Kompilator czasem ostrzega przed tym błędem komunikatem suggest parentheses around assignment used as truth value — czytaj ostrzeżenia, one naprawdę pomagają.
Porównywanie wyników działań
Po obu stronach porównania mogą stać całe działania. Komputer najpierw je liczy, a dopiero potem porównuje wyniki, bo porównania mają niższy priorytet niż + - * / %. Kilka warunków, które spotkasz w zadaniach bardzo często:
| Warunek | Co sprawdza |
|---|---|
a + b == c | czy suma a i b to c |
n % 10 == 0 | czy liczba kończy się zerem |
n % 5 == 0 | czy liczba dzieli się przez 5 |
a % 10 == b % 10 | czy a i b mają tę samą ostatnią cyfrę |
a * a == b | czy b to kwadrat liczby a |
cena * ile <= budzet | czy starczy pieniędzy na zakupy |
int a, b, odp;
cin >> a >> b >> odp;
if (a * b == odp) {
cout << "Dobrze!\n";
} else {
cout << "Zle, " << a << " * " << b << " = " << a * b << "\n";
}
Liczba zamiast warunku
W nawiasie if może stać też zwykła liczba: 0 oznacza fałsz, a każda inna liczba — prawdę (pamiętasz, że true to 1, a false to 0?). Zapis if (n) znaczy więc to samo co if (n != 0). Spotkasz to w cudzym kodzie. Sam na początku pisz pełne porównanie — jest czytelniejsze.
int reszta = 17 % 5;
if (reszta) {
cout << "nie dzieli sie, reszta " << reszta << "\n";
}
if (20 % 5) {
cout << "tego nie zobaczysz\n";
}
17 % 5 to 2, czyli prawda. 20 % 5 to 0, czyli fałsz — drugi napis się nie pokaże.
Porównywanie znaków
Zmienne typu char porównujesz tak samo, a znak piszesz w apostrofach: if (odp == 'T'). Pamiętasz z lekcji o typach, że każdy znak ma swój kod ASCII? Porównania < i > porównują właśnie te kody. Wystarczy zapamiętać trzy fakty:
| Fakt | Przykład |
|---|---|
małe litery mają kolejne kody, od 'a' (97) do 'z' (122) | 'b' < 'k' → true |
wielkie litery też, od 'A' (65) do 'Z' (90) — wszystkie są przed małymi | 'Z' < 'a' → true |
cyfry jako znaki: od '0' (48) do '9' (57) | '7' > '3' → true |
char c;
cin >> c; // na pewno litera
if (c >= 'a') {
cout << "mala litera\n";
} else {
cout << "wielka litera\n";
}
Ten program działa, bo wiemy, że na wejściu jest litera: wszystkie małe litery mają kod co najmniej 97 ('a'), a wszystkie wielkie — najwyżej 90 ('Z'). Jedno porównanie wystarczy, żeby je rozróżnić.
Gdyby na wejściu mógł być dowolny znak, np. cyfra albo ?, potrzebne byłyby dokładniejsze warunki. Nauczysz się ich w części 05.
'a' to znak (char), "a" to napis (string), a samo a to nazwa zmiennej. Znak porównuj ze znakiem w apostrofach: c == 'y'. Zapis c == "y" się nie skompiluje — kompilator nie umie porównać znaku z napisem.
Porównywanie napisów
Zmienne typu string też porównujesz zwykłymi operatorami. == sprawdza, czy napisy są identyczne — co do każdej litery i jej wielkości. Dzięki temu łatwo sprawdzić hasło:
string haslo;
cin >> haslo;
if (haslo == "bajtek123") {
cout << "Witaj!\n";
} else {
cout << "Bledne haslo\n";
}
A < sprawdza, który napis jest wcześniej w słowniku. Komputer porównuje litery od lewej, aż trafi na pierwszą różnicę — i o wszystkim decyduje ta jedna para liter. Jeśli jeden napis jest początkiem drugiego, krótszy jest pierwszy. Tak ustawisz dwa słowa w kolejności alfabetycznej:
string a, b;
cin >> a >> b;
if (a < b) {
cout << a << " " << b << "\n";
} else {
cout << b << " " << a << "\n";
}
| Porównanie | Wynik i dlaczego |
|---|---|
"ala" < "ola" | true — a jest przed o |
"kot" < "koc" | false — t jest za c |
"kot" < "kotek" | true — krótszy początek |
"Zosia" < "ala" | true — wielkie litery są przed małymi! |
Liczby z przecinkiem — ostrożnie z ==
Pamiętasz, że 0.1 + 0.2 to w komputerze nie dokładnie 0.3? Dlatego liczb double nie porównuj przez ==. Porównania <, >, <= i >= działają dobrze — o ile wynik obliczeń nie wypada dokładnie na granicy.
double a = 0.1 + 0.2;
if (a == 0.3) {
cout << "rowne\n";
} else {
cout << "rozne!\n";
}
Najprostsza rada: jeśli dane są liczbami całkowitymi, trzymaj się int — porównania na liczbach całkowitych są zawsze dokładne. Zamiast pytać, czy średnia z n ocen o sumie s wynosi co najmniej 4.75, możesz zapytać o to samo bez ułamków: 4 * s >= 19 * n (bo 4.75 = 19/4). Tę sztuczkę — pomnożenie obu stron przez mianownik — wykorzystasz w ćwiczeniach.
Warunek w zmiennej bool
Skoro warunek daje true albo false, możesz zapisać go w zmiennej typu bool, a potem użyć jej w if. Z dobrą nazwą kod czyta się jak zdanie:
int punkty;
cin >> punkty;
bool zdal = (punkty >= 50);
if (zdal) {
cout << "Zaliczone\n";
} else {
cout << "Poprawka\n";
}
if (zdal) znaczy dokładnie to samo co if (zdal == true), ale krócej. Takie zmienne bardzo się przydają, gdy warunek jest długi albo potrzebujesz go w kilku miejscach programu.
Każde pytanie sprawdza inną pułapkę z tej części.
int a = 2, b = 3;
if (a + b == 5) {
cout << "T";
} else {
cout << "N";
}
Pokaż odpowiedź
int x = 0;
if (x = 0) {
cout << "zero";
} else {
cout << "nie zero";
}
Pokaż odpowiedź
char c = 'B';
if (c < 'a') {
cout << "wielka";
} else {
cout << "mala";
}
Pokaż odpowiedź
string s = "kot";
if (s < "koc") {
cout << "1";
} else {
cout << "2";
}
Pokaż odpowiedź
int n = 15;
if (n % 10) {
cout << "A";
} else {
cout << "B";
}
Pokaż odpowiedź
string a = "Zosia", b = "ala";
if (a < b) {
cout << a;
} else {
cout << b;
}
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
else if — gdy możliwości jest więcej niż dwie
if … else wybiera jedną z dwóch dróg. A co, gdy dróg jest więcej? Liczba może być dodatnia, ujemna albo równa zero — to trzy przypadki. Ocena z klasówki ma sześć możliwości. Wtedy między if a else wstawiasz else if — „a w przeciwnym razie, jeżeli…”. Takich else if może być dowolnie dużo:
if (warunek1) {
// gdy warunek1 jest prawdziwy
} else if (warunek2) {
// gdy warunek1 był fałszywy, a warunek2 jest prawdziwy
} else if (warunek3) {
// gdy dwa pierwsze były fałszywe, a warunek3 jest prawdziwy
} else {
// gdy wszystkie warunki były fałszywe
}
Program sprawdza warunki po kolei, z góry na dół. Przy pierwszym prawdziwym wykonuje jego klamry i wychodzi z całego łańcucha — kolejnych warunków już nawet nie sprawdza. Jeśli żaden warunek nie jest prawdziwy, wykonuje się else na końcu. Znowu wykona się dokładnie jedna gałąź.
int n;
cin >> n;
if (n > 0) {
cout << "DODATNIA\n";
} else if (n < 0) {
cout << "UJEMNA\n";
} else {
cout << "ZERO\n";
}
| Linijka | n = 5 | n = −3 | n = 0 |
|---|---|---|---|
if (n > 0) | true → DODATNIA | false → dalej | false → dalej |
else if (n < 0) | nie sprawdza | true → UJEMNA | false → dalej |
else | pomija | pomija | ✓ ZERO |
Każdy kolejny warunek „wie”, że poprzednie były fałszywe
Zamieńmy punkty z klasówki (od 0 do 100) na ocenę. Skala: 95–100 to celujący, 85–94 bardzo dobry, 70–84 dobry, 55–69 dostateczny, 40–54 dopuszczający, a poniżej 40 — niedostateczny.
int p;
cin >> p;
if (p >= 95) {
cout << "celujacy\n";
} else if (p >= 85) {
cout << "bardzo dobry\n";
} else if (p >= 70) {
cout << "dobry\n";
} else if (p >= 55) {
cout << "dostateczny\n";
} else if (p >= 40) {
cout << "dopuszczajacy\n";
} else {
cout << "niedostateczny\n";
}
Dlaczego dla czwórki wystarczy p >= 70, a nie trzeba pisać „p ≥ 70 i p < 85”? Bo do tego miejsca program dochodzi tylko wtedy, gdy wszystkie wcześniejsze warunki były fałszywe — czyli już wiadomo, że p < 85.
Kolejność ma znaczenie
Z tego, że wygrywa pierwszy prawdziwy warunek, wynika najczęstsza pułapka. Gdy zaczniesz od najłagodniejszego warunku, prawie wszystko wpadnie do niego, a dalsze gałęzie nigdy się nie wykonają:
int p = 98;
if (p >= 40) {
cout << "dopuszczajacy\n";
} else if (p >= 95) {
cout << "celujacy\n"; // nigdy!
}
int p = 98;
if (p < 40) {
cout << "niedostateczny\n";
} else if (p < 95) {
cout << "od 2 do 5\n";
} else {
cout << "celujacy\n";
}
Zasada: przy warunkach z >= zaczynaj od największego progu i schodź w dół, a przy warunkach z < — od najmniejszego progu w górę (jak po prawej). Obie wersje są dobre; złe jest tylko mieszanie kolejności.
Łańcuch else if a osobne if-y
Porównaj dwa programy. Różnią się tylko słowem else, a robią coś zupełnie innego:
int p = 90;
if (p >= 85) {
cout << "bardzo dobry\n";
}
if (p >= 70) {
cout << "dobry\n";
}
if (p >= 55) {
cout << "dostateczny\n";
}
int p = 90;
if (p >= 85) {
cout << "bardzo dobry\n";
} else if (p >= 70) {
cout << "dobry\n";
} else if (p >= 55) {
cout << "dostateczny\n";
}
Osobne if-y są niezależne: każdy sprawdza się zawsze, więc wykonały się trzy. Łańcuch else if wybiera najwyżej jedną drogę. Gdy przypadki się wykluczają (ocena jest jedna), używaj łańcucha.
Czy else na końcu jest potrzebne?
Nie zawsze. Bez końcowego else może się zdarzyć, że nie wykona się żadna gałąź — i czasem właśnie o to chodzi. Medale dostają tylko trzy pierwsze miejsca, a podziękowanie — wszyscy:
int miejsce;
cin >> miejsce;
if (miejsce == 1) {
cout << "Zloty medal\n";
} else if (miejsce == 2) {
cout << "Srebrny medal\n";
} else if (miejsce == 3) {
cout << "Brazowy medal\n";
}
cout << "Dziekujemy za udzial\n";
else if kryje się na granicach przedziałów. Dla każdego progu sprawdź program na liczbie równej progowi i o jeden mniejszej: w programie z ocenami — na 95 i 94, 85 i 84, 70 i 69… Jeśli dla 85 wychodzi „dobry”, to pomyliłeś > z >=.
Pamiętaj: w łańcuchu else if wygrywa pierwszy prawdziwy warunek.
int x = 0;
if (x > 0) {
cout << "A";
} else if (x < 0) {
cout << "B";
} else {
cout << "C";
}
Pokaż odpowiedź
int t = 25;
if (t > 30) {
cout << "upal";
} else if (t > 20) {
cout << "cieplo";
} else if (t > 10) {
cout << "chlodno";
} else {
cout << "zimno";
}
Pokaż odpowiedź
int t = 25;
if (t > 10) {
cout << "chlodno";
} else if (t > 20) {
cout << "cieplo";
}
Pokaż odpowiedź
int n = 7;
if (n > 5) {
cout << "A";
}
if (n > 3) {
cout << "B";
} else if (n > 1) {
cout << "C";
}
Pokaż odpowiedź
int m = 4;
if (m == 1) {
cout << "zloto";
} else if (m == 2) {
cout << "srebro";
}
cout << "!";
Pokaż odpowiedź
int x = 15;
if (x % 3 == 0) {
cout << "Fizz";
} else if (x % 5 == 0) {
cout << "Buzz";
} else {
cout << x;
}
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Łączenie warunków: &&, || i !
Czasem jedno porównanie to za mało. „Na kolejkę górską wejdziesz, jeśli masz co najmniej 140 cm wzrostu i co najmniej 10 lat.” „Jest weekend, gdy jest sobota lub niedziela.” Operatory logiczne znasz już z lekcji o typie bool — teraz zobaczysz, jak wykorzystać je w if.
| Zapis | Czyta się | Prawda, gdy… | Przykład |
|---|---|---|---|
a && b | a oraz b | oba warunki są prawdziwe | wzrost >= 140 && wiek >= 10 |
a || b | a lub b | co najmniej jeden jest prawdziwy | dzien == 6 || dzien == 7 |
!a | nie a | a jest fałszywe | !(n % 2 == 0) — n nie jest parzyste |
int wzrost, wiek;
cin >> wzrost >> wiek;
if (wzrost >= 140 && wiek >= 10) {
cout << "Zapraszamy!\n";
} else {
cout << "Niestety nie\n";
}
Przy && wystarczy, że jeden warunek nie jest spełniony, a cały jest fałszywy — dlatego dwa ostatnie uruchomienia kończą się odmową, choć za każdym razem jeden z warunków był spełniony.
Liczba w przedziale
Jak sprawdzić, czy liczba leży między 1 a 10? W matematyce piszesz 1 ≤ x ≤ 10. W C++ trzeba to rozbić na dwa porównania połączone przez &&: x >= 1 && x <= 10. Czytaj: „x jest co najmniej 1 oraz x jest co najwyżej 10”. Zapis matematyczny się kompiluje, ale działa zupełnie inaczej:
int x = 500;
if (1 <= x <= 10) {
cout << "w przedziale\n";
} else {
cout << "poza\n";
}
int x = 500;
if (x >= 1 && x <= 10) {
cout << "w przedziale\n";
} else {
cout << "poza\n";
}
Po lewej komputer liczy od lewej: najpierw 1 <= 500 — prawda, czyli 1. Potem 1 <= 10 — też prawda. Dla każdego x wyjdzie prawda, bo 0 i 1 są zawsze mniejsze od 10.
A jak sprawdzić, że liczba jest poza przedziałem? Jest poza [1, 10], gdy jest mniejsza od 1 lub większa od 10: x < 1 || x > 10. Tu musi być || — żadna liczba nie jest jednocześnie mniejsza od 1 i większa od 10.
Jedna z kilku wartości
Gdy zmienna ma kilka „dobrych” wartości, łączysz porównania przez ||. Samogłoski w polskim alfabecie (bez polskich znaków) to a, e, i, o, u, y:
char c;
cin >> c;
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y') {
cout << "samogloska\n";
} else {
cout << "spolgloska\n";
}
c == 'a' || 'e'. To nie działa! 'e' samo w sobie to liczba 101, różna od zera — czyli zawsze prawda. Cały warunek byłby prawdziwy dla każdej litery. Każde porównanie piszesz w całości: c == 'a' || c == 'e'.
Znaki z przedziału: cyfry i litery
Ponieważ litery i cyfry mają kolejne kody, przedziały działają też na znakach. Teraz już dokładnie rozpoznasz każdy rodzaj znaku:
char c;
cin >> c;
if (c >= '0' && c <= '9') {
cout << "cyfra\n";
} else if (c >= 'a' && c <= 'z') {
cout << "mala litera\n";
} else if (c >= 'A' && c <= 'Z') {
cout << "wielka litera\n";
} else {
cout << "inny znak\n";
}
Nawiasy, gdy mieszasz && i ||
Rok jest przestępny, gdy dzieli się przez 4 i nie dzieli się przez 100 — albo gdy dzieli się przez 400. Tak jak w zdaniu, w warunku też trzeba pokazać, co łączy się z czym. Służą do tego nawiasy:
int rok;
cin >> rok;
if ((rok % 4 == 0 && rok % 100 != 0) || rok % 400 == 0) {
cout << "Luty ma 29 dni\n";
} else {
cout << "Luty ma 28 dni\n";
}
C++ ma swoją zasadę: && jest „silniejsze” niż ||, tak jak mnożenie jest silniejsze niż dodawanie. Ale zamiast ją pamiętać, zawsze stawiaj nawiasy, gdy w jednym warunku są oba operatory. Zobacz, jak bardzo zmienia się sens bez nawiasów. Ulga przysługuje uczniom (wiek < 19) i seniorom (wiek ≥ 65), ale tylko z legitymacją:
int wiek = 15;
bool legitymacja = false;
if ((wiek < 19 || wiek >= 65) && legitymacja) {
cout << "bilet ulgowy\n";
} else {
cout << "bilet normalny\n";
}
int wiek = 15;
bool legitymacja = false;
if (wiek < 19 || wiek >= 65 && legitymacja) {
cout << "bilet ulgowy\n";
} else {
cout << "bilet normalny\n";
}
Bez nawiasów komputer czyta prawy warunek jako wiek < 19 || (wiek >= 65 && legitymacja) — „każdy uczeń albo senior z legitymacją”. Uczeń bez legitymacji dostał ulgę, choć nie powinien.
! — zaprzeczenie
! odwraca odpowiedź: z prawdy robi fałsz, a z fałszu prawdę. Najczęściej stawia się go przed zmienną bool albo przed warunkiem w nawiasie:
int n;
cin >> n;
bool parzysta = (n % 2 == 0);
if (!parzysta) {
cout << "nieparzysta\n";
}
if (!(n >= 1 && n <= 10)) {
cout << "poza przedzialem 1-10\n";
}
cout << "koniec\n";
Zaprzeczenie całego warunku z && albo || można rozpisać bez !. Wystarczy zaprzeczyć każdą część i zamienić && na || (albo odwrotnie). Te zamiany nazywa się prawami De Morgana:
| Z zaprzeczeniem | To samo bez ! | Po polsku |
|---|---|---|
!(x >= 1 && x <= 10) | x < 1 || x > 10 | poza przedziałem 1–10 |
!(d == 6 || d == 7) | d != 6 && d != 7 | ani sobota, ani niedziela |
!(a > b) | a <= b | a nie jest większe od b |
Skrócone obliczanie — zabezpieczenie przed dzieleniem przez zero
C++ liczy warunek od lewej i przestaje, gdy wynik jest już przesądzony. Gdy lewa strona && jest fałszem, cały warunek i tak będzie fałszem — więc prawej strony komputer w ogóle nie liczy. Tak samo gdy lewa strona || jest prawdą. Wykorzystasz to do zabezpieczeń. Dzielenie (i reszta z dzielenia) przez zero wysypuje program — a tutaj nigdy do niego nie dojdzie:
int a, b;
cin >> a >> b;
if (b != 0 && a % b == 0) {
cout << "b dzieli a\n";
} else {
cout << "nie\n";
}
Dla b = 0 lewa strona b != 0 jest fałszem, więc a % b się nie wykonuje. Gdyby zamienić kolejność (a % b == 0 && b != 0), program najpierw spróbowałby dzielić przez zero i skończyłby się błędem. Kolejność warunków ma znaczenie!
Najpierw policz każdą część warunku osobno, a potem połącz wyniki.
int x = 7;
if (x > 5 && x < 10) {
cout << "T";
} else {
cout << "N";
}
Pokaż odpowiedź
int d = 3;
if (d == 6 || d == 7) {
cout << "weekend";
} else {
cout << "praca";
}
Pokaż odpowiedź
int x = 0;
if (!(x > 0)) {
cout << "A";
} else {
cout << "B";
}
Pokaż odpowiedź
char c = 'k';
if (c == 'a' || 'e') {
cout << "samogloska";
} else {
cout << "spolgloska";
}
Pokaż odpowiedź
int x = 20;
if (x < 5 || x > 15) {
cout << "poza";
} else {
cout << "w srodku";
}
Pokaż odpowiedź
bool a = true, b = false, c = false;
cout << (a || b && c) << ((a || b) && c);
Pokaż odpowiedź
8 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
if w środku if
W klamrach if może stać dowolny kod — także kolejny if. Taki if w środku if nazywamy zagnieżdżonym. Przydaje się, gdy drugie pytanie ma sens dopiero po odpowiedzi na pierwsze. Przy logowaniu najpierw sprawdzasz, czy taki użytkownik w ogóle istnieje, a dopiero potem — czy podał dobre hasło:
string login, haslo;
cin >> login >> haslo;
if (login == "bajtek") {
if (haslo == "tajne123") {
cout << "Witaj, bajtek!\n";
} else {
cout << "Zle haslo\n";
}
} else {
cout << "Nie ma takiego uzytkownika\n";
}
| Linijka | bajtek tajne123 | bajtek abc | ola tajne123 |
|---|---|---|---|
if (login == "bajtek") | true → do środka | true → do środka | false → do else |
if (haslo == "tajne123") | true → Witaj | false → Zle haslo | nie sprawdza |
else zewnętrzny | pomija | pomija | ✓ Nie ma takiego… |
Zauważ, że przy loginie „ola” program w ogóle nie sprawdza hasła — wewnętrzny if stoi w klamrach zewnętrznego, więc wykonuje się tylko wtedy, gdy zewnętrzny warunek jest prawdziwy.
Wcięcia pokazują, co jest w czym
Każdy poziom zagnieżdżenia to kolejne 4 spacje w prawo. Dzięki temu od razu widać strukturę programu: else stoi zawsze dokładnie pod if, do którego należy, a wszystko, co jest „w środku”, jest przesunięte dalej. Przy zagnieżdżaniu wcięcia i klamry są szczególnie ważne. Program z zagnieżdżonymi if-ami można narysować jako drzewo decyzji:
string pogoda;
int temp;
cin >> pogoda >> temp;
if (pogoda == "slonce") {
if (temp >= 25) {
cout << "plaza\n";
} else {
cout << "rower\n";
}
} else {
if (temp >= 15) {
cout << "kino\n";
} else {
cout << "planszowki\n";
}
}
Zagnieżdżanie czy &&?
Wiele zagnieżdżonych if-ów da się „spłaszczyć” za pomocą && i else if. Oba programy poniżej robią dokładnie to samo:
int n = 7;
if (n > 0) {
if (n % 2 == 0) {
cout << "dodatnia parzysta\n";
} else {
cout << "dodatnia nieparzysta\n";
}
} else {
cout << "niedodatnia\n";
}
int n = 7;
if (n > 0 && n % 2 == 0) {
cout << "dodatnia parzysta\n";
} else if (n > 0) {
cout << "dodatnia nieparzysta\n";
} else {
cout << "niedodatnia\n";
}
Którą wersję wybrać? Zagnieżdżaj, gdy drugie pytanie ma sens dopiero po pierwszym (jak hasło po loginie) — taki kod czyta się jak instrukcja krok po kroku. Spłaszczaj, gdy zagnieżdżenie robi się głębokie: przy trzech, czterech poziomach kod ucieka w prawo i łatwo się w nim zgubić.
Pułapka: else bez klamer należy do najbliższego if
Ten program wygląda tak, jakby dla x = 5 miał wypisać „male”. Wcięcie sugeruje, że else należy do pierwszego if. Ale kompilator nie patrzy na wcięcia — else bez klamer zawsze łączy się z najbliższym wolnym if, czyli tutaj z wewnętrznym:
int x = 5;
if (x > 10)
if (x > 20)
cout << "bardzo duze\n";
else
cout << "male\n";
cout << "koniec\n";
int x = 5;
if (x > 10) {
if (x > 20) {
cout << "bardzo duze\n";
}
} else {
cout << "male\n";
}
cout << "koniec\n";
Po lewej else należy do if (x > 20). Ponieważ zewnętrzny warunek x > 10 jest fałszywy, program pomija cały wewnętrzny if razem z jego else — i nie wypisuje nic poza „koniec”. Klamry po prawej jednoznacznie mówią, gdzie co należy. To kolejny powód, żeby zawsze pisać klamry.
Śledź program od zewnętrznego if do środka.
int a = 5, b = 3;
if (a > 0) {
if (b > 0) {
cout << "A";
} else {
cout << "B";
}
} else {
cout << "C";
}
Pokaż odpowiedź
a = -5:int a = -5, b = 3;
if (a > 0) {
if (b > 0) {
cout << "A";
} else {
cout << "B";
}
} else {
cout << "C";
}
Pokaż odpowiedź
int x = 15;
if (x > 10)
if (x > 20)
cout << "A";
else
cout << "B";
Pokaż odpowiedź
int x = 5;
if (x > 10)
if (x > 20)
cout << "A";
else
cout << "B";
cout << "!";
Pokaż odpowiedź
int n = 12;
if (n % 2 == 0) {
if (n % 3 == 0) {
cout << "6";
} else {
cout << "2";
}
} else {
cout << "1";
}
Pokaż odpowiedź
6 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Schematy, które przydają się w co drugim zadaniu
Znasz już wszystkie elementy instrukcji if. W tej części zobaczysz kilka gotowych sposobów ich użycia, które pojawiają się w zadaniach bez przerwy: największa z kilku liczb, zamiana dwóch zmiennych miejscami, ustawianie liczb w kolejności i liczenie, ile warunków jest spełnionych. Warto je znać na pamięć — gdy poznasz pętle, będziesz ich używać jeszcze częściej.
Największa z trzech liczb
Pomysł jest prosty: zapamiętaj pierwszą liczbę jako „największą do tej pory”, a potem porównuj z nią kolejne. Gdy któraś okaże się większa — ona zostaje nową największą.
int a, b, c;
cin >> a >> b >> c;
int najw = a; // na razie najlepsza jest a
if (b > najw) {
najw = b;
}
if (c > najw) {
najw = c;
}
cout << najw << "\n";
| Linijka (wejście 4 9 2) | Porównanie | najw |
|---|---|---|
int najw = a; | — | 4 |
if (b > najw) | 9 > 4 → true | 9 |
if (c > najw) | 2 > 9 → false | 9 |
Ten sposób działa dla dowolnej liczby zmiennych: dla czterech liczb dopisujesz czwarty if, dla pięciu — piąty. Z < zamiast > znajdziesz najmniejszą. Zauważ, że oba if-y są osobne, bez else — każdą liczbę trzeba porównać z dotychczasową najlepszą.
C++ ma też gotowe funkcje max i min (z biblioteki <algorithm>): max(a, b) daje większą z dwóch liczb, a największą z trzech dostaniesz jako max(max(a, b), c). Warto jednak umieć zrobić to samemu — w wielu zadaniach trzeba przy okazji zapamiętać coś więcej, np. kto ma najwięcej punktów.
int a = 4, b = 9, c = 2;
cout << max(a, b) << " " << min(a, b) << "\n";
cout << max(max(a, b), c) << "\n";
Zamiana miejscami
Jak zamienić wartości dwóch zmiennych? Pierwszy pomysł — a = b; b = a; — nie działa. Po pierwszej linijce stara wartość a przepada na zawsze. Potrzebna jest trzecia, pomocnicza zmienna — tak jak do zamiany soku i wody w dwóch szklankach potrzebujesz trzeciej, pustej szklanki:
int a = 3, b = 7;
a = b; // a = 7, trójka przepadła
b = a; // b = 7
cout << a << " " << b << "\n";
int a = 3, b = 7;
int t = a; // t = 3 (pusta szklanka)
a = b; // a = 7
b = t; // b = 3
cout << a << " " << b << "\n";
To samo robi gotowa funkcja swap(a, b) — zamienia wartości dwóch zmiennych tego samego typu. Działa też dla napisów: po swap(s, t) napisy zamienią się miejscami.
Dwie liczby w kolejności rosnącej
Połączenie if z zamianą daje bardzo przydatny schemat: jeśli liczby stoją w złej kolejności — zamień je. Po takim if wiesz na pewno, że a <= b, i dalej możesz z tego korzystać:
int a, b;
cin >> a >> b;
if (a > b) {
swap(a, b);
}
// tutaj na pewno a <= b
cout << a << " " << b << "\n";
Trzy liczby w kolejności rosnącej
Trzy liczby uporządkujesz trzema zamianami: popraw parę (a, b), potem parę (b, c) — po niej największa liczba na pewno stoi w c — i jeszcze raz parę (a, b), bo na miejsce b mogła trafić mniejsza liczba.
int a, b, c;
cin >> a >> b >> c;
if (a > b) { swap(a, b); }
if (b > c) { swap(b, c); } // teraz c jest największa
if (a > b) { swap(a, b); } // poprawiamy początek
cout << a << " " << b << " " << c << "\n";
| Po zamianie | 8 2 5 | 3 2 1 |
|---|---|---|
| start | 8 2 5 | 3 2 1 |
| (a, b) | 2 8 5 | 2 3 1 |
| (b, c) | 2 5 8 | 2 1 3 |
| (a, b) | 2 5 8 | 1 2 3 |
Dla 3 2 1 widać, po co trzecia zamiana: po dwóch pierwszych jedynka utknęła na środku.
Licznik — ile warunków jest spełnionych
Chcesz wiedzieć, ile z trzech liczb jest dodatnich? Utwórz licznik równy 0 i zwiększaj go o 1 przy każdym spełnionym warunku. Podobnie działa suma warunkowa — dodajesz tylko te liczby, które spełniają warunek:
int a, b, c;
cin >> a >> b >> c;
int ile = 0, suma = 0;
if (a > 0) { ile++; suma += a; }
if (b > 0) { ile++; suma += b; }
if (c > 0) { ile++; suma += c; }
cout << "dodatnich: " << ile << "\n";
cout << "ich suma: " << suma << "\n";
Flaga — zmienna bool, która pamięta odpowiedź
Czasem odpowiedź zależy od wielu osobnych sprawdzeń. Wtedy tworzysz zmienną bool, zwaną flagą, z wartością true („na razie wszystko w porządku”), i zmieniasz ją na false, gdy któreś sprawdzenie się nie uda. Na końcu wystarczy jeden if:
int d, m; // dzień i miesiąc
cin >> d >> m;
bool ok = true;
if (m < 1 || m > 12) { ok = false; }
if (d < 1 || d > 31) { ok = false; }
if (m == 2 && d > 29) { ok = false; }
if (ok) {
cout << "data moze byc poprawna\n";
} else {
cout << "zla data\n";
}
Każde sprawdzenie stoi osobno i jest proste. Łatwo dopisać kolejne, np. że kwiecień ma tylko 30 dni. Zrobisz to w ćwiczeniach.
Zapisuj na kartce wartości zmiennych po każdej linijce.
int a = 3, b = 8, c = 5;
int m = a;
if (b > m) { m = b; }
if (c > m) { m = c; }
cout << m;
Pokaż odpowiedź
int a = 3, b = 8;
a = b;
b = a;
cout << a << b;
Pokaż odpowiedź
int a = 3, b = 8;
int t = a;
a = b;
b = t;
cout << a << b;
Pokaż odpowiedź
int a = 4, b = 0, c = -2;
int ile = 0;
if (a > 0) { ile++; }
if (b > 0) { ile++; }
if (c > 0) { ile++; }
cout << ile;
Pokaż odpowiedź
int a = 9, b = 8, c = 7;
if (a > b) { swap(a, b); }
if (b > c) { swap(b, c); }
cout << a << b << c;
Pokaż odpowiedź
7 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
switch i operator ?:
Wszystko, co znajdziesz w tej części, da się napisać samym if. switch i ?: to tylko skróty, które w niektórych sytuacjach robią kod krótszym i czytelniejszym. Warto je znać, bo bardzo często spotkasz je w cudzych rozwiązaniach.
switch — wybór według jednej wartości
Gdy porównujesz jedną zmienną z wieloma konkretnymi wartościami (1, 2, 3… albo 'a', 'b', 'c'…), zamiast długiego łańcucha else if możesz napisać switch (po angielsku „przełącznik”):
int dzien;
cin >> dzien;
switch (dzien) {
case 1:
cout << "poniedzialek\n";
break;
case 2:
cout << "wtorek\n";
break;
case 3:
cout << "sroda\n";
break;
case 4:
cout << "czwartek\n";
break;
case 5:
cout << "piatek\n";
break;
case 6:
case 7:
cout << "weekend\n";
break;
default:
cout << "nie ma takiego dnia\n";
}
| Element | Znaczenie |
|---|---|
switch (dzien) | sprawdzamy wartość zmiennej dzien |
case 3: | „gdy dzien == 3, zacznij tutaj” |
break; | „koniec — wyjdź ze switch” |
case 6: case 7: | dwa przypadki z tym samym kodem — jak || |
default: | jak else — gdy nie pasuje żaden case |
switch działa tylko dla liczb całkowitych i znaków (int, long long, char). Dla string i double go nie użyjesz — tam zostaje if. Po case wpisujesz konkretną wartość, a nie warunek: case x > 5: nie zadziała. Do przedziałów też zostaje if.
Zapomniany break
case mówi tylko, gdzie zacząć. Bez break program po wykonaniu swojego przypadku leci dalej, do kolejnych — aż trafi na break albo koniec switch. To się nazywa „przelatywanie” (po angielsku fall-through):
int n = 1;
switch (n) {
case 1:
cout << "jeden\n";
case 2:
cout << "dwa\n";
case 3:
cout << "trzy\n";
break;
case 4:
cout << "cztery\n";
}
Program zaczął przy case 1, ale bez break wykonał też kod przypadków 2 i 3. Zatrzymał się dopiero na break w przypadku 3.
Czasem robi się to celowo — jak przy case 6: case 7: w poprzednim przykładzie — ale zwykle zapomniany break to po prostu błąd. Zasada: każdy case kończ break.
switch na znakach: kalkulator
Pamiętasz z lekcji Input / Output, jak wczytać dane w rodzaju 12:30? Tak samo wczytasz działanie 7*6: liczba, znak, liczba. A potem switch wybierze działanie według znaku:
int a, b;
char op;
cin >> a >> op >> b;
switch (op) {
case '+':
cout << a + b << "\n";
break;
case '-':
cout << a - b << "\n";
break;
case '*':
cout << a * b << "\n";
break;
default:
cout << "nieznane dzialanie\n";
}
Operator ?: — if … else w jednej linijce
Gdy if … else służy tylko do wybrania jednej z dwóch wartości, możesz użyć operatora warunkowego. Czyta się go jak pytanie: warunek ? wartość_gdy_prawda : wartość_gdy_fałsz.
int a, b;
cin >> a >> b;
int wieksza = (a > b) ? a : b;
cout << wieksza << "\n";
cout << (a % 2 == 0 ? "a parzysta" : "a nieparzysta") << "\n";
int a, b;
cin >> a >> b;
int wieksza;
if (a > b) {
wieksza = a;
} else {
wieksza = b;
}
cout << wieksza << "\n";
if (a % 2 == 0) {
cout << "a parzysta\n";
} else {
cout << "a nieparzysta\n";
}
W olimpijskich rozwiązaniach bardzo często zobaczysz linijkę cout << (ok ? "TAK" : "NIE") << "\n";. Nawias wokół całego ?: w cout jest obowiązkowy — z tego samego powodu, co nawias przy wypisywaniu porównań w lekcji o typie bool.
Zasada zdrowego rozsądku: ?: jest świetny do jednej krótkiej decyzji. Nie wkładaj jednego ?: w drugi — taki kod działa, ale nikt, łącznie z Tobą za tydzień, go nie przeczyta.
Przy switch pilnuj break, przy ?: — która wartość jest pierwsza.
int x = 2;
switch (x) {
case 1: cout << "A"; break;
case 2: cout << "B"; break;
default: cout << "C";
}
Pokaż odpowiedź
int x = 2;
switch (x) {
case 1: cout << "A";
case 2: cout << "B";
case 3: cout << "C";
}
Pokaż odpowiedź
int x = 9;
switch (x) {
case 1: cout << "A"; break;
default: cout << "D";
}
Pokaż odpowiedź
int a = 4, b = 9;
cout << (a > b ? a : b);
Pokaż odpowiedź
int n = 7;
cout << (n % 2 == 0 ? "TAK" : "NIE");
Pokaż odpowiedź
6 ćwiczeń do tej części
Kliknij zadanie — otworzy się w sprawdzarce w nowej karcie. Napisz program u siebie, sprawdź go na przykładzie, wklej cały kod i kliknij Wyślij. Utknąłeś? Każde zadanie ma wskazówkę.
Baza zadań: decyzje w praktyce
Znasz już wszystkie narzędzia do podejmowania decyzji: if, else, else if, łączenie warunków, zagnieżdżanie, typowe schematy oraz switch i ?:. Czas sprawdzić je na zadaniach, które łączą kilka z nich naraz. Zadania są ułożone od najłatwiejszego do najtrudniejszego: najpierw rozgrzewka, potem zadania średnie, a na końcu trudne — z szachownicą, trójkątami, kalendarzem i wielkim finałem, w którym przydaje się wszystko naraz.
Przy każdym zadaniu widać, jakich zagadnień używa — także tych z poprzednich lekcji, jak %, long long, dane typu 12:30 czy setfill. Jeśli coś brzmi obco, wróć do odpowiedniej części — mapa lekcji jest na górze strony.
else if), czy są niezależne (osobne if-y). 3) Zastanów się nad granicami: co dla liczby równej progowi, dla zera, dla liczb ujemnych? 4) Uruchom program na przykładzie i na kilku własnych danych — zwłaszcza na granicach. 5) Wyślij. Wskazówka przy każdym zadaniu pomoże, gdy utkniesz.
Rozgrzewka · zadania 1–8
Jeden albo dwa warunki naraz — sprawdź, czy pewnie czujesz if, else i else if.
Średnie · zadania 9–21
Kilka przypadków, łączenie warunków i schematy z lekcji: zamiany, licznik, przedziały.
Trudne · zadania 22–29
Szachownica, trójkąty, kalendarz i long long — a na końcu wielki finał, w którym przydaje się wszystko naraz.