C++ · Podstawy · Lekcja 03

Instrukcja if / else w C++

Do tej pory każdy Twój program robił zawsze to samo — linijka po linijce, bez względu na dane. Teraz nauczysz go podejmować decyzje: zrobić coś tylko wtedy, gdy warunek jest spełniony, wybrać jedną z dwóch dróg albo jedną z wielu. Poznasz if, else, else if, łączenie warunków, zagnieżdżanie, najważniejsze schematy z zadań olimpijskich oraz switch i operator ?:. Po każdej części czekają ćwiczenia ze sprawdzarką.

55 ćwiczeń w trakcie lekcji29 zadań w bazie na koniec84 ze sprawdzarką C++
Filmy z OKI

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ć.

Materiały Olimpijskiego Koła Informatycznego — kanał zewnętrzny. Kliknięcie odtwarza film tutaj, bez opuszczania strony.

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.

CZĘŚĆ 01–02

Pierwsza decyzja

if wykonuje kod tylko wtedy, gdy warunek jest spełniony, a else mówi, co zrobić w przeciwnym razie.

CZĘŚĆ 03–05

Warunki i wiele dróg

Porównania liczb, znaków i napisów, łańcuch else if i łączenie warunków przez &&, || i !.

CZĘŚĆ 06–07

Decyzje w praktyce

if w środku if, największa z trzech liczb, zamiana miejscami, ustawianie liczb w kolejności i liczenie.

CZĘŚĆ 08

Dwa skróty

switch i operator ?: — nie są konieczne, ale skracają kod i często zobaczysz je w cudzych rozwiązaniach.

Przypomnienie: złota zasada sprawdzarki Sprawdzarka porównuje Twoje wyjście z oczekiwanym znak po znaku, więc wypisujesz dokładnie to, o co prosi zadanie — bez „Podaj liczbę:” i bez dodatkowych słów. W tej lekcji bardzo często odpowiedzią będzie słowo, np. 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:

schemat_if.cpp
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.

kino.cpp
#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;
}
▶ Pierwsze uruchomienie — wejście
15
▶ Wyjście
Bilet do kina Znizka dla ucznia! Milego seansu
▶ Drugie uruchomienie — wejście
30
▶ Wyjście
Bilet do kina Milego seansu

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:

cout << "Bilet do kina" wiek < 18 ? TAK cout << "Znizka..." NIE cout << "Milego seansu"
Gdy warunek jest prawdziwy — idziemy w prawo, przez klamry. Gdy fałszywy — prosto w dół. Obie drogi spotykają się za klamrami.

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ń:

Linijkawiek = 15wiek = 30
cin >> wiek;wczytuje 15wczytuje 30
cout << "Bilet do kina\n";✓ wypisuje✓ wypisuje
if (wiek < 18)15 < 18 → true30 < 18 → false
cout << "Znizka dla ucznia!\n";✓ wypisuje✗ przeskakuje
cout << "Milego seansu\n";✓ wypisuje✓ wypisuje
Zapamiętaj To, co jest w klamrach 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:

rekord.cpp
int punkty;
cin >> punkty;
if (punkty >= 100) {
    cout << "Rekord!\n";
    cout << "Dostajesz odznake\n";
    punkty = punkty + 50;   // premia
}
cout << "Masz " << punkty << " pkt\n";
▶ Wejście
120
▶ Wyjście
Rekord! Dostajesz odznake Masz 170 pkt
▶ Wejście
80
▶ Wyjście
Masz 80 pkt

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.

bez_minusa.cpp
int x;
cin >> x;
if (x < 0) {
    x = -x;      // -7 staje się 7
}
cout << x << "\n";
▶ Wejście
-7
▶ Wyjście
7
▶ Wejście
12
▶ Wyjście
12
rabat.cpp
int cena;
cin >> cena;
if (cena > 100) {
    cena -= 20;   // rabat 20 zł
}
cout << "Do zaplaty: " << cena << " zl\n";
▶ Wejście
150
▶ Wyjście
Do zaplaty: 130 zl
▶ Wejście
90
▶ Wyjście
Do zaplaty: 90 zl

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:

autobusy.cpp
int osoby, miejsca;
cin >> osoby >> miejsca;
int autobusy = osoby / miejsca;
if (osoby % miejsca != 0) {
    autobusy++;   // ktoś się nie zmieścił
}
cout << autobusy << "\n";
▶ Wejście
50 12
▶ Wyjście
5
▶ Wejście
48 12
▶ Wyjście
4

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:

pogoda.cpp
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";
▶ Wejście
-5
▶ Wyjście
Mroz - zaloz czapke Temperatura: -5
▶ Wejście
32
▶ Wyjście
Upal - wez wode Temperatura parzysta Temperatura: 32
▶ Wejście
17
▶ Wyjście
Temperatura: 17

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:

srednik.cpp
int x = 3;
if (x > 10); {
    cout << "x jest duze\n";
}
cout << "koniec\n";
▶ Wyjście
x jest duze koniec

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:

bez_klamer.cpp
int x = 5;
if (x > 10)
    cout << "x jest duze\n";
    cout << "naprawde duze!\n";
cout << "koniec\n";
▶ Wyjście
naprawde duze! koniec

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.

Sprawdź się w głowie

Najpierw odpowiedz w myślach — prześledź program linijka po linijce — a dopiero potem kliknij „Pokaż odpowiedź”.

Co wypisze ten fragment?
int a = 7;
if (a > 5) {
    cout << "A";
}
cout << "B";
Pokaż odpowiedź
AB7 > 5 to prawda, więc wypisuje się A. B stoi poza klamrami, więc wypisuje się zawsze.
A gdy zmienimy wartość a?
int a = 3;
if (a > 5) {
    cout << "A";
}
cout << "B";
Pokaż odpowiedź
B3 > 5 to fałsz — program przeskakuje klamry. Zostaje tylko B.
Ile wyniesie n?
int n = 10;
if (n % 2 == 0) {
    n = n / 2;
}
cout << n;
Pokaż odpowiedź
510 jest parzyste (10 % 2 to 0), więc n zostaje podzielone przez 2.
Dwa if-y po kolei. Co wypisze program?
int x = 4;
if (x > 2) {
    x = x + 10;
}
if (x > 12) {
    x = 0;
}
cout << x;
Pokaż odpowiedź
0Pierwszy if zmienia x na 14. Drugi if sprawdza warunek już dla nowej wartości: 14 > 12, więc x staje się 0.
Uwaga na średnik!
int x = 1;
if (x == 2); {
    cout << "dwa";
}
cout << "!";
Pokaż odpowiedź
dwa!Średnik zakończył if, więc klamry wykonują się zawsze — mimo że x to nie 2.
Bez klamer. Co wypisze program?
int k = 0;
if (k > 0)
    cout << "plus";
cout << "koniec";
Pokaż odpowiedź
koniecDo if należy tylko pierwszy cout. Warunek jest fałszywy, więc „plus” się nie wypisze, a „koniec” wypisuje się zawsze.

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:

schemat_if_else.cpp
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:

parzystosc.cpp
#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    if (n % 2 == 0) {
        cout << "PARZYSTA\n";
    } else {
        cout << "NIEPARZYSTA\n";
    }
    return 0;
}
▶ Wejście
14
▶ Wyjście
PARZYSTA
▶ Wejście
7
▶ Wyjście
NIEPARZYSTA
cin >> n n % 2 == 0 ? TAK NIE "PARZYSTA" "NIEPARZYSTA" return 0;
Dwie drogi — zawsze dokładnie jedna z nich. Potem obie łączą się w jedną.

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.

Uwaga na liczby ujemne W C++ reszta z dzielenia liczby ujemnej też jest ujemna: -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.

przez_trzy.cpp
int n;
cin >> n;
if (n % 3 == 0) {
    cout << "TAK\n";
} else {
    cout << "NIE\n";
}
▶ Wejście
27
▶ Wyjście
TAK
▶ Wejście
28
▶ Wyjście
NIE

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.

zakupy.cpp
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";
}
▶ Wejście
50 35
▶ Wyjście
Kupujesz! Zostanie ci 15 zl
▶ Wejście
20 35
▶ Wyjście
Za malo pieniedzy Brakuje 15 zl

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:

wieksza.cpp
int a, b;
cin >> a >> b;
int wieksza;          // tworzymy ją PRZED if
if (a > b) {
    wieksza = a;
} else {
    wieksza = b;
}
cout << wieksza << "\n";
▶ Wejście
8 3
▶ Wyjście
8
▶ Wejście
4 9
▶ Wyjście
9
▶ Wejście
5 5
▶ Wyjście
5

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:

zasieg.cpp
int a, b;
cin >> a >> b;
if (a > b) {
    int wieksza = a;
} else {
    int wieksza = b;
}
cout << wieksza << "\n";
▶ Kompilator
error: 'wieksza' was not declared in this scope

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.

else_z_warunkiem.cpp
int n;
cin >> n;
if (n > 0) {
    cout << "dodatnia\n";
} else (n < 0) {
    cout << "ujemna\n";
}
▶ Kompilator
error: expected ';' before '{' token
dobrze.cpp
int n;
cin >> n;
if (n > 0) {
    cout << "dodatnia\n";
} else {
    cout << "niedodatnia\n";
}
▶ Wejście
-4
▶ Wyjście
niedodatnia

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:

dwa_ify.cpp
int monety;
cin >> monety;
if (monety >= 10) {
    monety -= 10;
    cout << "Kupiles miecz\n";
}
if (monety < 10) {
    cout << "Nie stac cie na miecz\n";
}
▶ Wejście
15
▶ Wyjście
Kupiles miecz Nie stac cie na miecz
if_else.cpp
int monety;
cin >> monety;
if (monety >= 10) {
    monety -= 10;
    cout << "Kupiles miecz\n";
} else {
    cout << "Nie stac cie na miecz\n";
}
▶ Wejście
15
▶ Wyjście
Kupiles miecz

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.

Sprawdź się w głowie

Pamiętaj: z if … else wykonuje się zawsze dokładnie jedna gałąź.

Co wypisze ten fragment?
int x = 4;
if (x > 4) {
    cout << "A";
} else {
    cout << "B";
}
Pokaż odpowiedź
B4 > 4 to fałsz (4 nie jest większe od samego siebie), więc wykonuje się else.
Liczba ujemna. Co wypisze program?
int x = -3;
if (x % 2 == 0) {
    cout << "P";
} else {
    cout << "N";
}
Pokaż odpowiedź
N−3 % 2 to −1, a nie 0, więc warunek jest fałszywy i wykonuje się else. Sprawdzanie parzystości przez == 0 działa dobrze także dla liczb ujemnych.
Co wypisze ten fragment?
cout << -7 % 2;
Pokaż odpowiedź
-1Reszta z dzielenia liczby ujemnej ma w C++ znak minus. Dlatego n % 2 == 1 nie wykrywa ujemnych liczb nieparzystych.
Wejście: 12. Co wypisze program?
int n;
cin >> n;
if (n >= 10) {
    n = n - 10;
} else {
    n = n + 10;
}
cout << n;
Pokaż odpowiedź
212 ≥ 10, więc wykonuje się pierwsza gałąź: 12 − 10 = 2. Gałąź else jest pomijana.
Dwa if … else po kolei. Co wypisze program?
int p = 8;
if (p > 5) {
    p = 2;
} else {
    p = 9;
}
if (p > 5) {
    cout << "duzo";
} else {
    cout << "malo";
}
Pokaż odpowiedź
maloPierwszy if … else zmienia p na 2. Drugi sprawdza już nową wartość: 2 > 5 to fałsz, więc „malo”.
Czy ten program się skompiluje?
if (a > b) {
    int m = a;
} else {
    int m = b;
}
cout << m;
Pokaż odpowiedź
nieZmienna m istnieje tylko w klamrach, w których ją utworzono. W ostatniej linijce jej już nie ma, więc kompilator zgłosi błąd. Utwórz m przed if.

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:

ZapisCzyta sięPrzykład warunkuCo sprawdza
a == ba równe bif (odp == 42)czy odpowiedź to dokładnie 42
a != ba różne od bif (n % 10 != 0)czy liczba nie kończy się zerem
a < ba mniejsze od bif (t < 0)czy jest mróz
a > ba większe od bif (wynik > rekord)czy padł nowy rekord
a <= ba mniejsze lub równe bif (waga <= 20)czy bagaż mieści się w limicie
a >= ba większe lub równe bif (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:

blad.cpp
int x = 3;
if (x = 5) {
    cout << "x to piec\n";
}
cout << "x = " << x << "\n";
▶ Wyjście
x to piec x = 5
dobrze.cpp
int x = 3;
if (x == 5) {
    cout << "x to piec\n";
}
cout << "x = " << x << "\n";
▶ Wyjście
x = 3

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:

WarunekCo sprawdza
a + b == cczy suma a i b to c
n % 10 == 0czy liczba kończy się zerem
n % 5 == 0czy liczba dzieli się przez 5
a % 10 == b % 10czy a i b mają tę samą ostatnią cyfrę
a * a == bczy b to kwadrat liczby a
cena * ile <= budzetczy starczy pieniędzy na zakupy
tabliczka.cpp
int a, b, odp;
cin >> a >> b >> odp;
if (a * b == odp) {
    cout << "Dobrze!\n";
} else {
    cout << "Zle, " << a << " * " << b << " = " << a * b << "\n";
}
▶ Wejście
7 8 56
▶ Wyjście
Dobrze!
▶ Wejście
6 7 48
▶ Wyjście
Zle, 6 * 7 = 42

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.

liczba_jako_warunek.cpp
int reszta = 17 % 5;
if (reszta) {
    cout << "nie dzieli sie, reszta " << reszta << "\n";
}
if (20 % 5) {
    cout << "tego nie zobaczysz\n";
}
▶ Wyjście
nie dzieli sie, reszta 2

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:

FaktPrzykł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
wielkosc_litery.cpp
char c;
cin >> c;   // na pewno litera
if (c >= 'a') {
    cout << "mala litera\n";
} else {
    cout << "wielka litera\n";
}
▶ Wejście
q
▶ Wyjście
mala litera
▶ Wejście
Q
▶ Wyjście
wielka litera

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.

Apostrofy czy cudzysłów? '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:

haslo.cpp
string haslo;
cin >> haslo;
if (haslo == "bajtek123") {
    cout << "Witaj!\n";
} else {
    cout << "Bledne haslo\n";
}
▶ Wejście
bajtek123
▶ Wyjście
Witaj!
▶ Wejście
Bajtek123
▶ Wyjście
Bledne haslo

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:

alfabetycznie.cpp
string a, b;
cin >> a >> b;
if (a < b) {
    cout << a << " " << b << "\n";
} else {
    cout << b << " " << a << "\n";
}
▶ Wejście
ola ala
▶ Wyjście
ala ola
▶ Wejście
kotek kot
▶ Wyjście
kot kotek
PorównanieWynik 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.

pulapka_double.cpp
double a = 0.1 + 0.2;
if (a == 0.3) {
    cout << "rowne\n";
} else {
    cout << "rozne!\n";
}
▶ Wyjście
rozne!

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:

zmienna_bool.cpp
int punkty;
cin >> punkty;
bool zdal = (punkty >= 50);
if (zdal) {
    cout << "Zaliczone\n";
} else {
    cout << "Poprawka\n";
}
▶ Wejście
73
▶ Wyjście
Zaliczone
▶ Wejście
41
▶ Wyjście
Poprawka

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.

Sprawdź się w głowie

Każde pytanie sprawdza inną pułapkę z tej części.

Co wypisze ten fragment?
int a = 2, b = 3;
if (a + b == 5) {
    cout << "T";
} else {
    cout << "N";
}
Pokaż odpowiedź
TNajpierw liczy się a + b = 5, dopiero potem porównanie 5 == 5.
Uwaga, podchwytliwe!
int x = 0;
if (x = 0) {
    cout << "zero";
} else {
    cout << "nie zero";
}
Pokaż odpowiedź
nie zeroTo przypisanie, a nie porównanie: x = 0 wkłada 0 do x i ma wartość 0, czyli fałsz. Wykonuje się else, choć x naprawdę jest zerem!
Co wypisze ten fragment?
char c = 'B';
if (c < 'a') {
    cout << "wielka";
} else {
    cout << "mala";
}
Pokaż odpowiedź
wielka'B' ma kod 66, a 'a' — 97. Wszystkie wielkie litery są przed małymi.
Który napis jest wcześniej w słowniku?
string s = "kot";
if (s < "koc") {
    cout << "1";
} else {
    cout << "2";
}
Pokaż odpowiedź
2Pierwsze dwie litery są takie same, a o wyniku decyduje trzecia: t jest za c. "kot" nie jest mniejsze od "koc".
Liczba jako warunek. Co wypisze program?
int n = 15;
if (n % 10) {
    cout << "A";
} else {
    cout << "B";
}
Pokaż odpowiedź
A15 % 10 to 5 — liczba różna od zera, czyli prawda.
Wielkie i małe litery. Co wypisze program?
string a = "Zosia", b = "ala";
if (a < b) {
    cout << a;
} else {
    cout << b;
}
Pokaż odpowiedź
ZosiaPorównujemy 'Z' (90) z 'a' (97). Wielka litera ma mniejszy kod, więc "Zosia" < "ala" — choć w słowniku byłoby odwrotnie.

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:

schemat_else_if.cpp
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łąź.

znak_liczby.cpp
int n;
cin >> n;
if (n > 0) {
    cout << "DODATNIA\n";
} else if (n < 0) {
    cout << "UJEMNA\n";
} else {
    cout << "ZERO\n";
}
▶ Wejście
5
▶ Wyjście
DODATNIA
▶ Wejście
-3
▶ Wyjście
UJEMNA
▶ Wejście
0
▶ Wyjście
ZERO
n > 0 ? TAK "DODATNIA" NIE n < 0 ? TAK "UJEMNA" NIE else: "ZERO" dalsza część
Warunki sprawdzane są z góry na dół. Pierwszy prawdziwy wygrywa — reszta jest pomijana.
Linijkan = 5n = −3n = 0
if (n > 0)true → DODATNIAfalse → dalejfalse → dalej
else if (n < 0)nie sprawdzatrue → UJEMNAfalse → dalej
elsepomijapomija✓ 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.

oceny.cpp
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";
}
▶ Wejście
88
▶ Wyjście
bardzo dobry
▶ Wejście
40
▶ Wyjście
dopuszczajacy
▶ Wejście
12
▶ Wyjście
niedostateczny

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ą:

zla_kolejnosc.cpp
int p = 98;
if (p >= 40) {
    cout << "dopuszczajacy\n";
} else if (p >= 95) {
    cout << "celujacy\n";      // nigdy!
}
▶ Wyjście
dopuszczajacy
od_dolu.cpp
int p = 98;
if (p < 40) {
    cout << "niedostateczny\n";
} else if (p < 95) {
    cout << "od 2 do 5\n";
} else {
    cout << "celujacy\n";
}
▶ Wyjście
celujacy

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:

osobne_ify.cpp
int p = 90;
if (p >= 85) {
    cout << "bardzo dobry\n";
}
if (p >= 70) {
    cout << "dobry\n";
}
if (p >= 55) {
    cout << "dostateczny\n";
}
▶ Wyjście
bardzo dobry dobry dostateczny
lancuch.cpp
int p = 90;
if (p >= 85) {
    cout << "bardzo dobry\n";
} else if (p >= 70) {
    cout << "dobry\n";
} else if (p >= 55) {
    cout << "dostateczny\n";
}
▶ Wyjście
bardzo dobry

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:

medale.cpp
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";
▶ Wejście
2
▶ Wyjście
Srebrny medal Dziekujemy za udzial
▶ Wejście
7
▶ Wyjście
Dziekujemy za udzial
Testuj na granicach Najwięcej błędów w łańcuchach 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 >=.
Sprawdź się w głowie

Pamiętaj: w łańcuchu else if wygrywa pierwszy prawdziwy warunek.

Co wypisze ten fragment?
int x = 0;
if (x > 0) {
    cout << "A";
} else if (x < 0) {
    cout << "B";
} else {
    cout << "C";
}
Pokaż odpowiedź
COba warunki są fałszywe (0 nie jest ani większe, ani mniejsze od 0), więc wykonuje się else.
Temperatura 25 stopni. Co wypisze program?
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ź
cieplo25 > 30 — nie. 25 > 20 — tak, więc „cieplo” i koniec łańcucha. Że 25 > 10, też jest prawdą, nie ma już znaczenia.
A teraz kolejność jest odwrócona:
int t = 25;
if (t > 10) {
    cout << "chlodno";
} else if (t > 20) {
    cout << "cieplo";
}
Pokaż odpowiedź
chlodnoPierwszy warunek jest prawdziwy, więc druga gałąź nigdy nie ma szansy. Zła kolejność progów!
Osobny if i łańcuch. Co wypisze program?
int n = 7;
if (n > 5) {
    cout << "A";
}
if (n > 3) {
    cout << "B";
} else if (n > 1) {
    cout << "C";
}
Pokaż odpowiedź
ABPierwszy if jest osobny — wypisuje A. Potem zaczyna się nowy łańcuch: 7 > 3, więc B, a C jest pomijane.
Bez else na końcu. Co wypisze program?
int m = 4;
if (m == 1) {
    cout << "zloto";
} else if (m == 2) {
    cout << "srebro";
}
cout << "!";
Pokaż odpowiedź
!Żaden warunek nie jest prawdziwy, a else nie ma — nie wykonuje się żadna gałąź.
Liczba 15. Co wypisze program?
int x = 15;
if (x % 3 == 0) {
    cout << "Fizz";
} else if (x % 5 == 0) {
    cout << "Buzz";
} else {
    cout << x;
}
Pokaż odpowiedź
Fizz15 dzieli się przez 3, więc wygrywa pierwsza gałąź. Że dzieli się też przez 5, program już nie sprawdza. Zapamiętaj ten przykład — przyda się w ćwiczeniach.

Łą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.

ZapisCzyta sięPrawda, gdy…Przykład
a && ba oraz boba warunki są prawdziwewzrost >= 140 && wiek >= 10
a || ba lub bco najmniej jeden jest prawdziwydzien == 6 || dzien == 7
!anie aa jest fałszywe!(n % 2 == 0) — n nie jest parzyste
kolejka.cpp
int wzrost, wiek;
cin >> wzrost >> wiek;
if (wzrost >= 140 && wiek >= 10) {
    cout << "Zapraszamy!\n";
} else {
    cout << "Niestety nie\n";
}
▶ Wejście
150 12
▶ Wyjście
Zapraszamy!
▶ Wejście
150 9
▶ Wyjście
Niestety nie
▶ Wejście
130 12
▶ Wyjście
Niestety nie

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:

zle_przedzial.cpp
int x = 500;
if (1 <= x <= 10) {
    cout << "w przedziale\n";
} else {
    cout << "poza\n";
}
▶ Wyjście
w przedziale
dobrze_przedzial.cpp
int x = 500;
if (x >= 1 && x <= 10) {
    cout << "w przedziale\n";
} else {
    cout << "poza\n";
}
▶ Wyjście
poza

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:

samogloska.cpp
char c;
cin >> c;
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y') {
    cout << "samogloska\n";
} else {
    cout << "spolgloska\n";
}
▶ Wejście
e
▶ Wyjście
samogloska
▶ Wejście
k
▶ Wyjście
spolgloska
Nie skracaj porównań Kusi, żeby napisać 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:

rodzaj_znaku.cpp
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";
}
▶ Wejście
7
▶ Wyjście
cyfra
▶ Wejście
g
▶ Wyjście
mala litera
▶ Wejście
G
▶ Wyjście
wielka litera
▶ Wejście
?
▶ Wyjście
inny znak

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:

przestepny.cpp
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";
}
▶ Wejście
2024
▶ Wyjście
Luty ma 29 dni
▶ Wejście
1900
▶ Wyjście
Luty ma 28 dni
▶ Wejście
2000
▶ Wyjście
Luty ma 29 dni

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ą:

z_nawiasami.cpp
int wiek = 15;
bool legitymacja = false;
if ((wiek < 19 || wiek >= 65) && legitymacja) {
    cout << "bilet ulgowy\n";
} else {
    cout << "bilet normalny\n";
}
▶ Wyjście
bilet normalny
bez_nawiasow.cpp
int wiek = 15;
bool legitymacja = false;
if (wiek < 19 || wiek >= 65 && legitymacja) {
    cout << "bilet ulgowy\n";
} else {
    cout << "bilet normalny\n";
}
▶ Wyjście
bilet ulgowy

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:

zaprzeczenie.cpp
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";
▶ Wejście
13
▶ Wyjście
nieparzysta poza przedzialem 1-10 koniec
▶ Wejście
4
▶ Wyjście
koniec

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 zaprzeczeniemTo samo bez !Po polsku
!(x >= 1 && x <= 10)x < 1 || x > 10poza przedziałem 1–10
!(d == 6 || d == 7)d != 6 && d != 7ani sobota, ani niedziela
!(a > b)a <= ba 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:

bez_dzielenia_przez_zero.cpp
int a, b;
cin >> a >> b;
if (b != 0 && a % b == 0) {
    cout << "b dzieli a\n";
} else {
    cout << "nie\n";
}
▶ Wejście
12 4
▶ Wyjście
b dzieli a
▶ Wejście
12 0
▶ Wyjście
nie

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!

Sprawdź się w głowie

Najpierw policz każdą część warunku osobno, a potem połącz wyniki.

Co wypisze ten fragment?
int x = 7;
if (x > 5 && x < 10) {
    cout << "T";
} else {
    cout << "N";
}
Pokaż odpowiedź
T7 > 5 i 7 < 10 — obie części prawdziwe, więc całość też.
Środa to dzień numer 3. Co wypisze program?
int d = 3;
if (d == 6 || d == 7) {
    cout << "weekend";
} else {
    cout << "praca";
}
Pokaż odpowiedź
pracaObie części są fałszywe, więc || daje fałsz.
Co wypisze ten fragment?
int x = 0;
if (!(x > 0)) {
    cout << "A";
} else {
    cout << "B";
}
Pokaż odpowiedź
A0 > 0 to fałsz, a ! odwraca go na prawdę.
Litera k. Co wypisze program?
char c = 'k';
if (c == 'a' || 'e') {
    cout << "samogloska";
} else {
    cout << "spolgloska";
}
Pokaż odpowiedź
samogloskaBłąd skracania! Prawa strona || to samo 'e', czyli liczba 101 — zawsze prawda. Poprawnie: c == 'a' || c == 'e'.
Co wypisze ten fragment?
int x = 20;
if (x < 5 || x > 15) {
    cout << "poza";
} else {
    cout << "w srodku";
}
Pokaż odpowiedź
poza20 > 15 — wystarczy jedna prawdziwa część ||.
Kolejność działań: co wypisze program?
bool a = true, b = false, c = false;
cout << (a || b && c) << ((a || b) && c);
Pokaż odpowiedź
10Bez nawiasów najpierw liczy się b && c (fałsz), a potem a || fałsz — prawda, czyli 1. Z nawiasami najpierw a || b (prawda), a potem prawda && c — fałsz, czyli 0.

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:

logowanie.cpp
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";
}
▶ Wejście
bajtek tajne123
▶ Wyjście
Witaj, bajtek!
▶ Wejście
bajtek abc
▶ Wyjście
Zle haslo
▶ Wejście
ola tajne123
▶ Wyjście
Nie ma takiego uzytkownika
Linijkabajtek tajne123bajtek abcola tajne123
if (login == "bajtek")true → do środkatrue → do środkafalse → do else
if (haslo == "tajne123")true → Witajfalse → Zle haslonie sprawdza
else zewnętrznypomijapomija✓ 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:

wycieczka.cpp
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";
    }
}
▶ Wejście
slonce 28
▶ Wyjście
plaza
▶ Wejście
deszcz 10
▶ Wyjście
planszowki
pogoda == "slonce" ? TAK NIE temp >= 25 ? temp >= 15 ? TAK NIE TAK NIE plaza rower kino planszowki
Każda ścieżka od góry do dołu to jedna możliwa odpowiedź programu. Dwa pytania „tak/nie” dają cztery odpowiedzi.

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:

zagniezdzone.cpp
int n = 7;
if (n > 0) {
    if (n % 2 == 0) {
        cout << "dodatnia parzysta\n";
    } else {
        cout << "dodatnia nieparzysta\n";
    }
} else {
    cout << "niedodatnia\n";
}
▶ Wyjście
dodatnia nieparzysta
splaszczone.cpp
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";
}
▶ Wyjście
dodatnia nieparzysta

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:

wiszacy_else.cpp
int x = 5;
if (x > 10)
    if (x > 20)
        cout << "bardzo duze\n";
else
    cout << "male\n";
cout << "koniec\n";
▶ Wyjście
koniec
z_klamrami.cpp
int x = 5;
if (x > 10) {
    if (x > 20) {
        cout << "bardzo duze\n";
    }
} else {
    cout << "male\n";
}
cout << "koniec\n";
▶ Wyjście
male koniec

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.

Sprawdź się w głowie

Śledź program od zewnętrznego if do środka.

Co wypisze ten fragment?
int a = 5, b = 3;
if (a > 0) {
    if (b > 0) {
        cout << "A";
    } else {
        cout << "B";
    }
} else {
    cout << "C";
}
Pokaż odpowiedź
Aa > 0 — wchodzimy do środka. b > 0 — wypisujemy A.
Ten sam kod, ale a = -5:
int a = -5, b = 3;
if (a > 0) {
    if (b > 0) {
        cout << "A";
    } else {
        cout << "B";
    }
} else {
    cout << "C";
}
Pokaż odpowiedź
CZewnętrzny warunek jest fałszywy, więc wewnętrzny if w ogóle nie jest sprawdzany — od razu zewnętrzny else.
Do którego if należy else?
int x = 15;
if (x > 10)
    if (x > 20)
        cout << "A";
    else
        cout << "B";
Pokaż odpowiedź
Belse należy do najbliższego if, czyli do if (x > 20). 15 > 10, ale 15 nie jest większe od 20 — wypisuje się B.
A gdy x = 5?
int x = 5;
if (x > 10)
    if (x > 20)
        cout << "A";
    else
        cout << "B";
cout << "!";
Pokaż odpowiedź
!Zewnętrzny warunek jest fałszywy, a cały wewnętrzny if razem z else należy do niego — więc nic się nie wypisuje oprócz wykrzyknika.
Liczba 12. Co wypisze program?
int n = 12;
if (n % 2 == 0) {
    if (n % 3 == 0) {
        cout << "6";
    } else {
        cout << "2";
    }
} else {
    cout << "1";
}
Pokaż odpowiedź
612 jest parzyste i dzieli się przez 3 — czyli dzieli się przez 6.

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ą.

najwieksza.cpp
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";
▶ Wejście
4 9 2
▶ Wyjście
9
▶ Wejście
7 3 7
▶ Wyjście
7
▶ Wejście
-5 -2 -8
▶ Wyjście
-2
Linijka (wejście 4 9 2)Porównanienajw
int najw = a;—4
if (b > najw)9 > 4 → true9
if (c > najw)2 > 9 → false9

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.

max_min.cpp
int a = 4, b = 9, c = 2;
cout << max(a, b) << " " << min(a, b) << "\n";
cout << max(max(a, b), c) << "\n";
▶ Wyjście
9 4 9

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:

zla_zamiana.cpp
int a = 3, b = 7;
a = b;      // a = 7, trójka przepadła
b = a;      // b = 7
cout << a << " " << b << "\n";
▶ Wyjście
7 7
zamiana.cpp
int a = 3, b = 7;
int t = a;  // t = 3 (pusta szklanka)
a = b;      // a = 7
b = t;      // b = 3
cout << a << " " << b << "\n";
▶ Wyjście
7 3

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ć:

dwie_rosnaco.cpp
int a, b;
cin >> a >> b;
if (a > b) {
    swap(a, b);
}
// tutaj na pewno a <= b
cout << a << " " << b << "\n";
▶ Wejście
9 4
▶ Wyjście
4 9
▶ Wejście
2 6
▶ Wyjście
2 6

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.

trzy_rosnaco.cpp
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";
▶ Wejście
8 2 5
▶ Wyjście
2 5 8
▶ Wejście
3 2 1
▶ Wyjście
1 2 3
Po zamianie8 2 53 2 1
start8 2 53 2 1
(a, b)2 8 52 3 1
(b, c)2 5 82 1 3
(a, b)2 5 81 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:

licznik.cpp
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";
▶ Wejście
5 -3 8
▶ Wyjście
dodatnich: 2 ich suma: 13
▶ Wejście
-1 -2 -3
▶ Wyjście
dodatnich: 0 ich suma: 0

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:

flaga.cpp
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";
}
▶ Wejście
17 5
▶ Wyjście
data moze byc poprawna
▶ Wejście
30 2
▶ Wyjście
zla data
▶ Wejście
12 13
▶ Wyjście
zla data

Każde sprawdzenie stoi osobno i jest proste. Łatwo dopisać kolejne, np. że kwiecień ma tylko 30 dni. Zrobisz to w ćwiczeniach.

Sprawdź się w głowie

Zapisuj na kartce wartości zmiennych po każdej linijce.

Co wypisze ten fragment?
int a = 3, b = 8, c = 5;
int m = a;
if (b > m) { m = b; }
if (c > m) { m = c; }
cout << m;
Pokaż odpowiedź
8m: 3 → 8 (bo 8 > 3) → zostaje 8 (bo 5 nie jest większe od 8).
Zła zamiana. Co wypisze program?
int a = 3, b = 8;
a = b;
b = a;
cout << a << b;
Pokaż odpowiedź
88Po a = b obie zmienne mają 8, a trójka przepadła. b = a nic już nie zmienia.
A teraz z pomocniczą zmienną:
int a = 3, b = 8;
int t = a;
a = b;
b = t;
cout << a << b;
Pokaż odpowiedź
83t przechowało trójkę, więc po zamianie a = 8, b = 3.
Ile liczb jest dodatnich?
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ź
1Tylko 4 jest dodatnie. Zero nie jest ani dodatnie, ani ujemne!
Tylko dwie zamiany zamiast trzech. Co wypisze program?
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ź
879Po pierwszej zamianie: 8 9 7, po drugiej: 8 7 9. Największa jest już na końcu, ale początek jest zły — dlatego potrzebna jest trzecia zamiana.

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”):

dzien_tygodnia.cpp
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";
}
▶ Wejście
3
▶ Wyjście
sroda
▶ Wejście
7
▶ Wyjście
weekend
▶ Wejście
9
▶ Wyjście
nie ma takiego dnia
ElementZnaczenie
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
Kiedy switch nie zadziała 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):

bez_break.cpp
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";
}
▶ Wyjście
jeden dwa trzy

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:

kalkulator.cpp
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";
}
▶ Wejście
7*6
▶ Wyjście
42
▶ Wejście
9-12
▶ Wyjście
-3
▶ Wejście
8^2
▶ Wyjście
nieznane dzialanie

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.

ternary.cpp
int a, b;
cin >> a >> b;
int wieksza = (a > b) ? a : b;
cout << wieksza << "\n";
cout << (a % 2 == 0 ? "a parzysta" : "a nieparzysta") << "\n";
▶ Wejście
8 3
▶ Wyjście
8 a parzysta
to_samo_z_if.cpp
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";
}
▶ Wejście
8 3
▶ Wyjście
8 a parzysta

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.

Sprawdź się w głowie

Przy switch pilnuj break, przy ?: — która wartość jest pierwsza.

Co wypisze ten fragment?
int x = 2;
switch (x) {
    case 1: cout << "A"; break;
    case 2: cout << "B"; break;
    default: cout << "C";
}
Pokaż odpowiedź
Bx to 2, więc program zaczyna przy case 2, wypisuje B i break kończy switch.
Bez break:
int x = 2;
switch (x) {
    case 1: cout << "A";
    case 2: cout << "B";
    case 3: cout << "C";
}
Pokaż odpowiedź
BCZaczyna przy case 2 i bez break „przelatuje” do case 3. Case 1 jest powyżej, więc go nie wykonuje.
Co wypisze ten fragment?
int x = 9;
switch (x) {
    case 1: cout << "A"; break;
    default: cout << "D";
}
Pokaż odpowiedź
DŻaden case nie pasuje, więc wykonuje się default.
Operator ?:
int a = 4, b = 9;
cout << (a > b ? a : b);
Pokaż odpowiedź
94 > 9 to fałsz, więc wybierana jest wartość po dwukropku — b.
TAK czy NIE?
int n = 7;
cout << (n % 2 == 0 ? "TAK" : "NIE");
Pokaż odpowiedź
NIE7 % 2 to 1, warunek jest fałszywy, więc „NIE”.

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.

Jak rozwiązywać zadania z warunkami 1) Przeczytaj treść i wypisz sobie wszystkie przypadki: co ma się stać, gdy… 2) Dla każdego przypadku ustal warunek i zdecyduj, czy przypadki się wykluczają (łańcuch 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.
średnie

Średnie · zadania 9–21

Kilka przypadków, łączenie warunków i schematy z lekcji: zamiany, licznik, przedziały.

9 Kamień, papier, nożyceśrednie✓ zaliczone K, P albo N dwóch graczy — kto wygrał? char&&||else if Rozwiąż 10 Zegar 12-godzinnyśrednie✓ zaliczone Zamień 14:05 na 2:05 PM, a 00:30 na 12:30 AM. char jako separatorelse ifsetfill Rozwiąż 11 Jaki to trójkąt?średnie✓ zaliczone Czy z trzech odcinków powstanie trójkąt? Równoboczny, równoramienny czy różnoboczny? &&||else ifnierówność trójkąta Rozwiąż 12 Czy odcinki się nakładają?średnie✓ zaliczone Dwa odcinki na osi — mają choć jeden wspólny punkt? ||!przedziały Rozwiąż 13 Ruch skoczkaśrednie✓ zaliczone Czy konik szachowy dojdzie z pola na pole jednym ruchem? charwartość bezwzględna&&|| Rozwiąż 14 Jaki dzień będzie za k dni?średnie✓ zaliczone Dziś dzień numer d — jaki dzień tygodnia będzie za k dni? %switch Rozwiąż 15 Lista obecnościśrednie✓ zaliczone Trzy imiona — ułóż je w kolejności alfabetycznej. stringswapsortowanie trzech Rozwiąż 16 Najbliższa wielokrotnośćśrednie✓ zaliczone Która wielokrotność liczby k leży najbliżej n? %if … elseremis Rozwiąż 17 Koniec filmuśrednie✓ zaliczone Film zaczyna się o HH:MM i trwa t minut. O której się skończy? char jako separatorsetfillprzejście przez północ Rozwiąż 18 Cennik paczekśrednie✓ zaliczone Waga w gramach i rodzaj dostawy → cena albo odmowa. else ifcharjednostki Rozwiąż 19 Podatek progowyśrednie✓ zaliczone 12% do 120 000 zł, 32% od nadwyżki — policz podatek. if … elsedoublesetprecision(2)zakres int Rozwiąż 20 Ile trafień?średnie✓ zaliczone Trzy Twoje liczby i trzy wylosowane — ile trafiłeś? licznik|| Rozwiąż 21 Ile jabłek?średnie✓ zaliczone 1 jablko, 2 jablka, 5 jablek — dobierz końcówkę jak w języku polskim. %&&||else if Rozwiąż

Częste błędy i dobre praktyki

🟰
==, a nie =
W warunku porównujesz przez ==. if (x = 5) to przypisanie: zawsze „prawda” i po cichu psuje zmienną.
🚫
Bez średnika po if
if (x > 10); kończy instrukcję if — klamry za nim wykonują się zawsze. Po nawiasie od razu otwierasz klamrę.
🔲
Zawsze klamry
Bez klamer do if należy tylko jedna instrukcja, a else łączy się z najbliższym if. Klamry kosztują dwa znaki i oszczędzają godzin szukania błędów.
↕️
Kolejność w else if
Wygrywa pierwszy prawdziwy warunek. Przy >= zaczynaj od największego progu, przy < — od najmniejszego. Najpierw sprawdzaj przypadki szczególne (np. FizzBuzz przed Fizz).
📏
a <= x <= b nie działa
Przedział zapisujesz dwoma porównaniami: x >= a && x <= b. Poza przedziałem: x < a || x > b.
✂️
Nie skracaj porównań
c == 'a' || 'e' jest zawsze prawdą. Każde porównanie piszesz w całości: c == 'a' || c == 'e'.
( )
Nawiasy przy && i ||
Gdy w jednym warunku mieszasz && i ||, dodaj nawiasy: (a || b) && c to coś innego niż a || (b && c).
➖
Ujemne liczby i %
-7 % 2 to -1. Parzystość sprawdzaj przez n % 2 == 0 lub n % 2 != 0, nigdy przez n % 2 == 1.
📦
Zmienna przed if
Zmienna utworzona w klamrach znika za nimi. Jeśli potrzebujesz wyniku po if, utwórz zmienną przed nim, a w gałęziach tylko zmieniaj jej wartość.
🧱
Testuj granice
Sprawdź program dla liczby równej progowi i o jeden mniejszej, dla zera i dla liczb ujemnych. Tam kryje się większość błędów > zamiast >=.
🛡️
Najpierw zabezpieczenie
b != 0 && a % b == 0 — dzięki skróconemu obliczaniu dzielenie przez zero nigdy się nie wykona. Odwrotna kolejność wysypie program.
🔤
TAK to nie Tak
Odpowiedzi przepisuj z treści zadania co do litery. Sprawdzarka odróżnia wielkie litery od małych, a 'a' (znak) od "a" (napis) odróżnia nawet kompilator.

Co dalej?

Następna lekcja to While loop: program nauczy się powtarzać instrukcje tak długo, jak warunek jest prawdziwy — i wszystko, czego nauczyłeś się tutaj o warunkach, przyda się od pierwszej linijki. A jeśli chcesz trenować z mentorami — dołącz do T-Olimpians.