7.1 -- Instrukcje złożone (bloki)

instrukcja złożona (zwana także blok lub instrukcja blokowa) to grupa zero lub więcej instrukcji , która jest traktowana przez kompilator tak, jakby była pojedynczą instrukcją.

Bloki zaczynają się od symbolu { symbol, koniec na } , a pomiędzy nimi umieszczane są instrukcje do wykonania. Bloków można używać wszędzie tam, gdzie dozwolona jest pojedyncza instrukcja. Na końcu bloku nie jest potrzebny średnik.

Widzieliście już przykład bloków podczas pisania funkcji, ponieważ treścią funkcji jest blok:

int add(int x, int y)
{ // start block
    return x + y;
} // end block (no semicolon)

int main()
{ // start block

    // multiple statements
    int value {}; // to jest inicjalizacja, a nie blok
    add(3, 4);

    return 0;

} // end block (no semicolon)

Bloki wewnątrz innych bloków

Chociaż funkcji nie można zagnieżdżać w innych funkcjach, bloki można zagnieżdżać w innych blokach:

int add(int x, int y)
{ // block
    return x + y;
} // end block

int main()
{ // outer block

    // multiple statements
    int value {};

    { // blok wewnętrzny/zagnieżdżony
        add(3, 4);
    } // koniec bloku wewnętrznego/zagnieżdżonego

    return 0;

} // koniec bloku zewnętrznego

Kiedy bloki są zagnieżdżone, blok otaczający jest zwykle nazywany blokiem zewnętrznym a zamknięty blok nazywa się blokiem wewnętrznym lub blokiem zagnieżdżonym.

Używanie bloków do warunkowego wykonywania wielu instrukcji

Jednym z najczęstszych przypadków użycia bloków jest połączenie z if statements. Domyślnie if statement wykonuje pojedynczą instrukcję, jeśli warunek ma wartość true. Możemy jednak zastąpić tę pojedynczą instrukcję blokiem instrukcji, jeśli chcemy, aby wiele instrukcji zostało wykonanych, gdy warunek przyjmie wartość true.

Na przykład:

#include <iostream>

int main()
{ // początek bloku zewnętrznego
    std::cout << "Enter an integer: ";
    int value {};
    std::cin >> value;
    
    if (value >= 0)
    { // początek zagnieżdżonego bloku
        std::cout << value << " is a positive integer (or zero)\n";
        std::cout << "Double this number is " << value * 2 << '\n';
    } // koniec zagnieżdżonego bloku
    else
    { // początek kolejnego zagnieżdżonego bloku
        std::cout << value << " is a negative integer\n";
        std::cout << "The positive of this number is " << -value << '\n';
    } // koniec kolejnego zagnieżdżonego bloku

    return 0;
} // koniec bloku zewnętrznego

Jeśli użytkownik wprowadzi liczbę 3, ten program wyświetli:

Enter an integer: 3
3 is a positive integer (or zero)
Double this number is 6

Jeśli użytkownik wprowadzi liczbę -4, ten program wypisze:

Enter an integer: -4
-4 is a negative integer
The positive of this number is 4

Poziomy zagnieżdżenia bloku

Możliwe jest nawet umieszczenie bloków wewnątrz bloków wewnątrz bloki:

#include <iostream>

int main()
{ // blok 1, poziom zagnieżdżenia 1
    std::cout << "Enter an integer: ";
    int value {};
    std::cin >> value;
    
    if (value >  0)
    { // blok 2, poziom zagnieżdżenia 2
        if ((value % 2) == 0)
        { // blok 3, poziom zagnieżdżenia 3
            std::cout << value << " is positive and even\n";
        }
        else
        { // blok 4, również poziom zagnieżdżenia 3
            std::cout << value << " is positive and odd\n";
        }
    }

    return 0;
}

Klasa poziom zagnieżdżenia (zwane także głębokość zagnieżdżenia) funkcji to maksymalna liczba zagnieżdżonych bloków, w których możesz się znajdować w dowolnym punkcie funkcji (łącznie z blokiem zewnętrznym). W powyższej funkcji znajdują się 4 bloki, ale poziom zagnieżdżenia wynosi 3, ponieważ w tym programie nie możesz nigdy znajdować się w więcej niż 3 blokach w dowolnym momencie.

Standard C++ mówi, że kompilatory C++ powinny obsługiwać 256 poziomów zagnieżdżenia - jednak nie wszystkie to obsługują (np. w chwili pisania tego tekstu Visual Studio obsługuje mniej).

Dobrze jest utrzymywać poziom zagnieżdżenia na poziomie 3 lub niższym. Tak jak zbyt długie funkcje są dobrymi kandydatami do refaktoryzacji (podziału na mniejsze funkcje), tak nadmiernie zagnieżdżone bloki są trudne do odczytania i są dobrymi kandydatami do refaktoryzacji (najbardziej zagnieżdżone bloki stają się oddzielnymi funkcjami).