Instrukcje warunkowe to podstawowe elementy w programowaniu, które pozwalają na podejmowanie decyzji w zależności od spełnienia określonych warunków. Dzięki nim programy mogą wykonywać różne akcje w oparciu o dostarczone dane lub aktualny stan aplikacji. Instrukcje warunkowe umożliwiają tworzenie dynamicznych i interaktywnych aplikacji, które reagują na różne sytuacje. W tej lekcji omówimy, jak działają instrukcje warunkowe, jakie są ich rodzaje oraz jak efektywnie ich używać w różnych kontekstach.

Co to są instrukcje warunkowe?

Instrukcje warunkowe to konstrukcje, które umożliwiają wykonywanie określonych fragmentów kodu tylko wtedy, gdy spełniony jest określony warunek. Najbardziej popularne instrukcje warunkowe to if, else, else if (lub elif w Pythonie) oraz instrukcje switch, które są dostępne w niektórych językach, takich jak C++ i Java.

Podstawowa składnia instrukcji if

Instrukcja if sprawdza, czy podany warunek jest prawdziwy. Jeśli tak, kod wewnątrz bloku if jest wykonywany.

C++:

int liczba = 10;
if (liczba > 5) {
    std::cout << "Liczba jest większa niż 5" << std::endl;
}

Python:

liczba = 10
if liczba > 5:
    print("Liczba jest większa niż 5")

W obu przypadkach kod wewnątrz instrukcji if zostanie wykonany, ponieważ warunek liczba > 5 jest prawdziwy.

Instrukcja if-else

Instrukcja if-else pozwala na wykonanie alternatywnego fragmentu kodu, gdy warunek if nie jest spełniony.

C++:

int liczba = 3;
if (liczba > 5) {
    std::cout << "Liczba jest większa niż 5" << std::endl;
} else {
    std::cout << "Liczba jest mniejsza lub równa 5" << std::endl;
}

Python:

liczba = 3
if liczba > 5:
    print("Liczba jest większa niż 5")
else:
    print("Liczba jest mniejsza lub równa 5")

W tym przypadku, ponieważ warunek liczba > 5 nie jest spełniony, wykonany zostanie blok else.

Instrukcja else if / elif

Instrukcja else if (w C++) lub elif (w Pythonie) umożliwia sprawdzanie wielu warunków. Kod wewnątrz pierwszego spełnionego warunku zostanie wykonany, a reszta warunków zostanie zignorowana.

C++:

int liczba = 7;
if (liczba > 10) {
    std::cout << "Liczba jest większa niż 10" << std::endl;
} else if (liczba > 5) {
    std::cout << "Liczba jest większa niż 5, ale mniejsza lub równa 10" << std::endl;
} else {
    std::cout << "Liczba jest mniejsza lub równa 5" << std::endl;
}

Python:

liczba = 7
if liczba > 10:
    print("Liczba jest większa niż 10")
elif liczba > 5:
    print("Liczba jest większa niż 5, ale mniejsza lub równa 10")
else:
    print("Liczba jest mniejsza lub równa 5")

Instrukcje else if/elif pozwalają na tworzenie bardziej złożonych warunków i obsługę wielu przypadków.

Instrukcje warunkowe switch (C++ i Java)

Instrukcja switch jest wygodna, gdy mamy do czynienia z wieloma możliwymi wartościami zmiennej. Działa w niektórych językach, takich jak C++, Java czy C#.

Składnia instrukcji switch

C++:

int wybor = 2;
switch (wybor) {
    case 1:
        std::cout << "Wybrano 1" << std::endl;
        break;
    case 2:
        std::cout << "Wybrano 2" << std::endl;
        break;
    case 3:
        std::cout << "Wybrano 3" << std::endl;
        break;
    default:
        std::cout << "Nieprawidłowy wybór" << std::endl;
        break;
}

Instrukcja switch sprawdza wartość zmiennej wybor i wykonuje odpowiedni blok kodu. Instrukcja break przerywa wykonywanie switch, aby zapobiec przechodzeniu do kolejnych przypadków.

Złożone warunki logiczne

Instrukcje warunkowe mogą sprawdzać bardziej złożone warunki, wykorzystując operatory logiczne, takie jak && (i), || (lub) oraz ! (negacja).

Przykład: Operator &&

C++:

int wiek = 20;
if (wiek > 18 && wiek < 30) {
    std::cout << "Jesteś w przedziale wiekowym 19-29 lat" << std::endl;
}

Python:

wiek = 20
if wiek > 18 and wiek < 30:
    print("Jesteś w przedziale wiekowym 19-29 lat")

Przykład: Operator ||

C++:

char znak = 'a';
if (znak == 'a' || znak == 'e' || znak == 'i' || znak == 'o' || znak == 'u') {
    std::cout << "To jest samogłoska" << std::endl;
}

Python:

znak = 'a'
if znak in ['a', 'e', 'i', 'o', 'u']:
    print("To jest samogłoska")

Przykład: Operator !

C++:

bool aktywny = false;
if (!aktywny) {
    std::cout << "Użytkownik nie jest aktywny" << std::endl;
}

Python:

aktywny = False
if not aktywny:
    print("Użytkownik nie jest aktywny")

Wartość logiczna warunków

Warunki w instrukcjach if muszą mieć wartość logiczną: prawda (true) lub fałsz (false). W C++ każda liczba różna od zera jest traktowana jako prawda, a zero jako fałsz. W Pythonie wartości, takie jak None, 0, pusty ciąg (""), pusty słownik ({}) czy pusta lista ([]), są traktowane jako fałsz.

Przykład w C++: Liczby jako warunki

int liczba = 0;
if (liczba) {
    std::cout << "Liczba jest prawdą" << std::endl;
} else {
    std::cout << "Liczba jest fałszem" << std::endl;
}

Przykład w Pythonie: Różne wartości jako warunki

wartosc = ""
if wartosc:
    print("Wartość jest prawdą")
else:
    print("Wartość jest fałszem")

Pusty ciąg znaków "" jest traktowany jako fałsz.

Zagnieżdżone instrukcje warunkowe

Możemy używać zagnieżdżonych instrukcji if, co oznacza, że wewnątrz jednego bloku if może znajdować się kolejna instrukcja if.

Przykład zagnieżdżonych instrukcji if

C++:

int liczba = 10;
if (liczba > 5) {
    std::cout << "Liczba jest większa niż 5" << std::endl;
    if (liczba < 15) {
        std::cout << "Liczba jest również mniejsza niż 15" << std::endl;
    }
}

Python:

liczba = 10
if liczba > 5:
    print("Liczba jest większa niż 5")
    if liczba < 15:
        print("Liczba jest również mniejsza niż 15")

Zagnieżdżone instrukcje warunkowe są przydatne, gdy musimy sprawdzić kilka powiązanych warunków, ale mogą uczynić kod mniej czytelnym, jeśli są używane w nadmiarze.

Dobre praktyki w używaniu instrukcji warunkowych

1. Czytelność kodu: Staraj się, aby warunki były jak najbardziej zrozumiałe. Używaj komentarzy, jeśli warunki są skomplikowane.
2. Unikaj nadmiernego zagnieżdżania: Głębokie zagnieżdżanie instrukcji if może uczynić kod trudnym do odczytania. Rozważ podział kodu na funkcje, aby zwiększyć jego przejrzystość.
3. Optymalizacja: Jeśli masz wiele warunków, które mogą być sprawdzane za pomocą instrukcji switch, rozważ jej użycie, aby zwiększyć efektywność kodu.
4. Zastosowanie operatorów logicznych: Używaj operatorów logicznych, aby uprościć kod i uniknąć powtarzania tych samych instrukcji.

Przykłady zastosowania instrukcji warunkowych w praktyce

Przykład: Walidacja danych wejściowych

C++:

int wiek;
std::cout << "Podaj swój wiek: ";
std::cin >> wiek;
if (wiek < 0) {
    std::cout << "Wiek nie może być ujemny!" << std::endl;
} else if (wiek < 18) {
    std::cout << "Jesteś niepełnoletni." << std::endl;
} else {
    std::cout << "Jesteś pełnoletni." << std::endl;
}

Python:

wiek = int(input("Podaj swój wiek: "))
if wiek < 0:
    print("Wiek nie może być ujemny!")
elif wiek < 18:
    print("Jesteś niepełnoletni.")
else:
    print("Jesteś pełnoletni.")

Przykład: Sprawdzanie poprawności hasła

C++:

std::string haslo;
std::cout << "Podaj hasło: ";
std::cin >> haslo;
if (haslo == "tajnehaslo") {
    std::cout << "Hasło poprawne." << std::endl;
} else {
    std::cout << "Niepoprawne hasło!" << std::endl;
}

Python:

haslo = input("Podaj hasło: ")
if haslo == "tajnehaslo":
    print("Hasło poprawne.")
else:
    print("Niepoprawne hasło!")

Podsumowanie

Instrukcje warunkowe są kluczowym elementem w programowaniu, umożliwiając podejmowanie decyzji i kontrolowanie przepływu programu na podstawie warunków. Omówiliśmy różne rodzaje instrukcji warunkowych, takie jak if, else, else if/elif oraz switch. Zrozumienie, jak działają te instrukcje i jak ich efektywnie używać, jest niezbędne do tworzenia dynamicznych i funkcjonalnych programów. Pamiętaj, aby pisać warunki w sposób czytelny i unikać nadmiernego zagnieżdżania, aby utrzymać kod przejrzysty i łatwy do debugowania. W następnych lekcjach zajmiemy się bardziej zaawansowanymi technikami programowania.

Następny temat ==> Pętle while: Powtarzanie kodu aż do spełnienia warunku