if-else w C++: instrukcje warunkowe z przykładami

Podejmowanie decyzji z if

Programy ciągle reagują na dane: zaliczone czy nie, dostępne czy wyprzedane, poprawne czy błędne. Instrukcja if to sposób, w jaki C++ wybiera, który kod uruchomić na podstawie warunku.

if przyjmuje warunek w nawiasach i wykonuje blok w klamrach tylko wtedy, gdy ten warunek jest prawdziwy:

#include <iostream>
using namespace std;

int main() {
    int score = 72;

    if (score >= 60) {
        cout << "You passed!" << endl;
    }

    cout << "Done grading." << endl;
    return 0;
}

Warunek score >= 60 jest prawdziwy, więc komunikat się wypisuje. Linia po klamrze zamykającej wykonuje się zawsze, bo leży poza if. Zmień score na 40, a linia o zaliczeniu zostanie całkowicie pominięta.

Warunek jest konwertowany na bool. Porównania takie jak >, >=, ==, != już zwracają bool, ale C++ traktuje też każdą niezerową liczbę jako prawdę, a 0 jako fałsz, więc if (count) znaczy „jeśli count nie jest zerem”. Ta niejawna konwersja jest wygodna, ale jest też źródłem kilku klasycznych błędów, które zobaczysz niżej.

Dodanie else

else daje ścieżkę „w przeciwnym razie”: kod, który wykonuje się tylko wtedy, gdy warunek jest fałszywy:

#include <iostream>
using namespace std;

int main() {
    int hour = 20;

    if (hour < 12) {
        cout << "Good morning" << endl;
    } else {
        cout << "Good evening" << endl;
    }
    return 0;
}

Wykonuje się dokładnie jeden z dwóch bloków: nigdy oba i nigdy żaden. else nie ma własnego warunku; po prostu łapie wszystko, czego nie złapało if.

Łańcuchy z else if

Gdy możliwych wyników jest więcej niż dwa, połącz warunki w łańcuch przez else if. C++ sprawdza je od góry do dołu i wykonuje pierwszy blok, którego warunek jest prawdziwy, a resztę pomija:

#include <iostream>
using namespace std;

int main() {
    int score = 84;
    char grade;

    if (score >= 90) {
        grade = 'A';
    } else if (score >= 80) {
        grade = 'B';
    } else if (score >= 70) {
        grade = 'C';
    } else {
        grade = 'F';
    }

    cout << "Grade: " << grade << endl;
    return 0;
}

Kolejność ma znaczenie. Ponieważ 84 jest najpierw sprawdzane z >= 90 (fałsz), a potem z >= 80 (prawda), wykonanie zatrzymuje się na B i niższe progi w ogóle nie są sprawdzane. Dlatego też nie potrzebujesz score >= 80 && score < 90: dojście do drugiej gałęzi już gwarantuje, że score było poniżej 90. Najwęższy albo najważniejszy warunek umieszczaj jako pierwszy.

Zauważ, że w C++ nie ma słowa kluczowego elif: else if to dosłownie else, którego ciałem jest kolejne if. Klamry sprawiają tylko, że czyta się to jak jedną drabinkę.

Wielka pułapka: = a ==

Najczęstszy błąd w instrukcjach if w C i C++ to napisanie = (przypisanie) tam, gdzie chodziło o == (porównanie):

#include <iostream>
using namespace std;

int main() {
    int x = 0;

    if (x = 5) {   // BŁĄD: przypisuje 5 do x, potem sprawdza 5 (zawsze prawda)
        cout << "This always runs, and x is now " << x << endl;
    }
    return 0;
}

x = 5 przypisuje 5 do x, a całe wyrażenie ma wartość 5, która konwertuje się na true, więc gałąź wykonuje się zawsze, a ty po cichu nadpisujesz x. To się kompiluje; większość kompilatorów zgłasza tylko ostrzeżenie. Są dwie obrony: włącz ostrzeżenia (-Wall), żeby kompilator to wskazał, i rozważ umieszczanie stałej po lewej stronie, czyli if (5 == x), bo if (5 = x) to twardy błąd, który kompilator wyłapie od razu.

Ta sama pułapka czai się przy bool: if (ready = true) kompiluje się i przypisuje, a if (ready == true) (albo po prostu if (ready)) porównuje.

Łączenie i zagnieżdżanie warunków

Łącz warunki przez && (i), || (lub) oraz ! (nie) albo zagnieźdź jedno if w drugim, gdy sprawdzenie ma sens dopiero po spełnieniu wcześniejszego:

#include <iostream>
using namespace std;

int main() {
    int age = 25;
    bool hasLicense = true;

    if (age >= 18 && hasLicense) {
        cout << "Can drive" << endl;
    } else {
        cout << "Cannot drive" << endl;
    }

    // zagnieżdżanie: drugi warunek sprawdzamy tylko wtedy, gdy pierwszy jest spełniony
    if (age >= 18) {
        if (hasLicense) {
            cout << "Eligible and licensed" << endl;
        }
    }
    return 0;
}

&& i || działają na skróty: w a && b, jeśli a jest fałszem, C++ w ogóle nie oblicza b. To kluczowe przy ochronie przed błędnym dostępem do pamięci: if (ptr != nullptr && ptr->ready) jest bezpieczne, bo dereferencja wskaźnika jest pomijana, gdy ptr jest null. Jeśli możesz, spłaszczaj warunki przez && zamiast głęboko zagnieżdżać; płaski warunek czyta się łatwiej niż piramidę klamer.

Uważaj na łańcuchy porównań, które nie znaczą tego, na co wyglądają: if (0 < x < 10) nie sprawdza zakresu. Najpierw oblicza 0 < x do bool (0 albo 1), a potem porównuje to z 10, co zawsze jest prawdą. Zamiast tego napisz if (0 < x && x < 10).

Operator trójargumentowy

Gdy chcesz tylko wybrać jedną z dwóch wartości, operator trójargumentowy ?: daje zwięzły zapis w jednej linii. Czytaj condition ? a : b jako „jeśli warunek, to a, w przeciwnym razie b”:

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 15;

    string label = age >= 18 ? "adult" : "minor";
    cout << label << endl;

    int a = 7, b = 3;
    int largest = a > b ? a : b;
    cout << "largest = " << largest << endl;
    return 0;
}

Operator trójargumentowy zwraca wartość, którą możesz od razu przypisać, przekazać albo wypisać, czego zwykłe if nie potrafi. Zostaw go do prostego wyboru: jeśli któraś gałąź potrzebuje kilku instrukcji albo prawdziwej logiki, pełne if-else pozostaje czytelne, a zagnieżdżony operator trójargumentowy szybko robi się łamigłówką. (Jeden niuans: obie gałęzie muszą mieć wspólny typ, więc nie mieszaj na przykład napisu z int.)

if z inicjalizatorem (C++17)

Od C++17 możesz zadeklarować zmienną bezpośrednio w if, z zasięgiem ograniczonym do if/else. Dzięki temu krótko żyjące zmienne pomocnicze nie wyciekają do otaczającego kodu:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string text = "hello world";

    if (size_t pos = text.find("world"); pos != string::npos) {
        cout << "found at index " << pos << endl;
    } else {
        cout << "not found" << endl;
    }

    // pos jest tu poza zasięgiem: istniała tylko wewnątrz if/else
    return 0;
}

Część przed ; wykonuje się raz, a jej wynik jest widoczny zarówno w warunku, jak i w else. To świetne rozwiązanie dla wzorca „oblicz coś, a potem rozgałęź się na tej podstawie”, a ponieważ rzutowanie lub konwersja wyniku odbywa się raz na początku, unikasz ponownego liczenia albo przypadkowego użycia nieaktualnej wartości później. Sięgaj po nie zawsze, gdy zmienna tymczasowa jest potrzebna tylko w tej gałęzi.

Pułapka: brakujące klamry

C++ pozwala pominąć klamry, gdy gałąź ma jedną instrukcję, ale to zaprasza subtelny błąd, bo wcięcia kłamią:

if (loggedIn)
    cout << "Welcome\n";
    cout << "Loading dashboard\n";   // NIE należy do if!

if kontroluje tylko pierwszą linię; druga wykonuje się zawsze, niezależnie od loggedIn, choć wcięcie sugeruje coś innego. Pokrewny klasyk to zabłąkany średnik: if (x > 0); kończy if pustym ciałem, więc następujący po nim blok wykonuje się bezwarunkowo. Zawsze używaj klamer, nawet dla jednej linii, a większość błędów tego rodzaju zniknie.

Dalej: switch

Łańcuchy if-else if są idealne, gdy każda gałąź sprawdza inny warunek. Ale gdy porównujesz jedną wartość z wieloma stałymi możliwościami (wybór z menu, enum, kod statusu), długa drabinka else if staje się powtarzalna i łatwo pomylić w niej kolejność. Instrukcja switch powstała właśnie do tego i jest tematem następnej strony.