Dokumentacja C z przykładami: break i continue

Q: Jaka jest różnica między break a continue w C?

break całkowicie kończy pętlę i wykonanie wraca za nią. continue porzuca tylko bieżący obieg i przechodzi do następnego: w pętli for do części aktualizującej, a w while i do-while od razu do sprawdzenia warunku.

Q: Jak wyjść z zagnieżdżonej pętli w C?

Pojedynczy break opuszcza tylko najbardziej wewnętrzną pętlę. Żeby wyjść z obu, ustaw flagę i sprawdzaj ją w warunku pętli zewnętrznej, użyj goto, by skoczyć do etykiety za pętlami, albo, co zwykle jest najczystsze, przenieś pętle do funkcji i użyj return.

Q: Czy break wychodzi z pętli, czy tylko ze switch?

Z tego, co otacza go najbliżej. break wewnątrz switch, który jest w pętli, kończy tylko switch; pętla działa dalej. Żeby opuścić pętlę z wnętrza switch, potrzebujesz flagi, goto albo return.

Q: Dlaczego continue powoduje nieskończoną pętlę while?

Bo continue skacze do warunku i pomija resztę ciała, łącznie z inkrementacją licznika, jeśli stoi na końcu. W pętli for aktualizacja jest w nagłówku, więc wykonuje się zawsze; w pętli while przenieś aktualizację przed continue albo użyj for.

Dwa sposoby na zmianę przebiegu pętli

Warunek pętli decyduje, kiedy się ona kończy, ale czasem prawdziwa odpowiedź pojawia się w środku ciała. Przeszukujesz tablicę i znajdujesz element na trzeciej pozycji: po co sprawdzać pozostałe 997? Albo przetwarzasz listę i jeden wpis jest pusty: pomiń go i idź dalej.

C ma po jednym słowie kluczowym na każdy przypadek:

break: opuść pętlę teraz. Wykonanie wraca do pierwszej instrukcji za nią.
continue: porzuć tylko ten obieg. Przejdź do następnego.

#include <stdio.h>

int main(void) {
    printf("break przy 5:    ");
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            break;
        }
        printf("%d ", i);
    }
    printf("\n");

    printf("continue przy 5: ");
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            continue;
        }
        printf("%d ", i);
    }
    printf("\n");

    return 0;
}

Pierwsza pętla wypisuje 1 2 3 4 i się zatrzymuje. Druga wypisuje 1 2 3 4 6 7 8 9 10: pominęła jedną wartość i poszła dalej.

break w pętli

Kanoniczne zastosowanie to wyszukiwanie, które kończy się zaraz po sukcesie:

#include <stdio.h>

int main(void) {
    int data[] = {14, 3, 88, 27, 5, 62};
    int n = sizeof(data) / sizeof(data[0]);
    int target = 27;
    int found = -1;

    for (int i = 0; i < n; i++) {
        if (data[i] == target) {
            found = i;
            break;              /* nie ma powodu sprawdzać reszty */
        }
    }

    if (found >= 0) {
        printf("Znaleziono %d pod indeksem %d\n", target, found);
    } else {
        printf("%d nie ma w tablicy\n", target);
    }

    return 0;
}

Ponieważ found jest ustawiane przed break, kod za pętlą potrafi odróżnić "znaleziono" od "skończyły się elementy". Taka para, czyli zmienna na wynik plus break, to standardowy idiom wyszukiwania w C. Sam licznik pętli nie nadaje się do użycia później, gdy jest zadeklarowany w nagłówku, bo wychodzi z zasięgu przy nawiasie zamykającym.

break zawsze opuszcza jedną pętlę: najbliższe otaczające for, while, do-while albo switch.

continue w pętli

continue służy do wpisów, które należy pominąć, zamiast przerywać pracę:

#include <stdio.h>

int main(void) {
    int values[] = {12, -3, 0, 45, -7, 8};
    int n = sizeof(values) / sizeof(values[0]);
    int sum = 0, counted = 0;

    for (int i = 0; i < n; i++) {
        if (values[i] <= 0) {
            continue;           /* pomija zero i liczby ujemne */
        }
        sum += values[i];
        counted++;
    }

    printf("Suma %d dodatnich wartosci: %d\n", counted, sum);
    return 0;
}

To, dokąd skacze continue, zależy od pętli:

for        -> do części aktualizującej nagłówka (licznik i tak się zwiększa)
while      -> do sprawdzenia warunku (nic więcej z ciała się nie wykona)
do-while   -> do sprawdzenia warunku na dole

Ta różnica nie jest akademicka. W pętli for instrukcja continue nigdy nie pominie inkrementacji licznika, bo inkrementacja jest w nagłówku. W pętli while może:

/* BUG: continue pomija i++, więc to zawiesza się na pierwszej liczbie parzystej */
int i = 0;
while (i < 10) {
    if (i % 2 == 0) {
        continue;
    }
    printf("%d ", i);
    i++;
}

Przenieś i++ nad continue albo zapisz to jako pętlę for, w której nagłówek nie pozwala się pomylić.

break w switch to nie break w pętli

break kończy najbliższą otaczającą pętlę albo switch, zależnie od tego, co jest bliżej. Umieść switch w pętli, a każdy break w nim należy do switch:

#include <stdio.h>

int main(void) {
    char commands[] = "aabqcc";

    for (int i = 0; commands[i] != '\0'; i++) {
        switch (commands[i]) {
            case 'a':
                printf("dodaj\n");
                break;          /* kończy switch; pętla działa dalej */
            case 'b':
                printf("wstecz\n");
                break;
            case 'q':
                printf("zadano wyjscia\n");
                break;          /* też tylko switch! */
            default:
                printf("nieznane: %c\n", commands[i]);
                break;
        }
    }

    printf("petla zakonczona\n");
    return 0;
}

Polecenie q wypisuje swój komunikat, a pętla dalej przechodzi przez cc. Jeśli wyjście miało zakończyć pętlę, ten break tego nie zrobił. Rozwiązania to flaga, goto albo przeniesienie pętli do funkcji i użycie return; wszystkie pokazane są niżej.

Wychodzenie z zagnieżdżonych pętli

Pojedynczy break opuszcza jeden poziom. W dwóch zagnieżdżonych pętlach kończy tylko wewnętrzną, a zewnętrzna zaczyna kolejny obieg, jakby nic się nie stało.

#include <stdio.h>

int main(void) {
    int grid[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    /* break opuszcza tylko pętlę wewnętrzną, zewnętrzna działa dalej */
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("wewnetrzny break w wierszu %d\n", r);
                break;
            }
        }
    }
    printf("(zewnetrzna petla przeszla wszystkie 3 wiersze)\n");
    return 0;
}

C nie ma break 2 ani break z etykietą. Są trzy uczciwe opcje:

Flaga. Przenośna, oczywista i trochę gadatliwa:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    int found = 0;

    for (int r = 0; r < 3 && !found; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("Znaleziono 7 w wierszu %d, kolumnie %d\n", r, c);
                found = 1;
                break;
            }
        }
    }

    return 0;
}

Flaga pojawia się w dwóch miejscach, w zewnętrznym warunku i w przypisaniu, i to jest jej koszt. Przy trzech poziomach zagnieżdżenia robi się naprawdę nieprzyjemnie.

goto. Mocno oczerniany skok w C, a to jedyny przypadek, w którym doświadczeni programiści C używają go bez przepraszania:

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};

    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("Znaleziono 7 w wierszu %d, kolumnie %d\n", r, c);
                goto done;
            }
        }
    }
    printf("nie znaleziono\n");

done:
    printf("wyszukiwanie zakonczone\n");
    return 0;
}

goto w przód do etykiety tuż za pętlami robi dokładnie to, co break z etykietą w innych językach, w jednej linii i bez flagi, którą trzeba utrzymywać w zgodzie. Złą reputację goto zawdzięcza skokom wstecz i skokom do środka innych bloków, które rzeczywiście dają nieczytelny przepływ sterowania. Pojedynczy skok w przód z zagnieżdżonych pętli to nie to samo. Jądro Linuksa używa tego samego wzorca w ścieżkach sprzątania. Używaj go świadomie i oszczędnie; nie pozwól, żeby tabu zepchnęło cię do rozwiązania z trzema flagami, które czyta się trudniej.

Funkcja i return. Zwykle najlepsza odpowiedź, bo wyszukiwanie zasługuje na nazwę:

#include <stdio.h>

/* zwraca 1 i zapisuje pozycję, gdy znajdzie, w przeciwnym razie 0 */
int findValue(int grid[3][4], int target, int *outRow, int *outCol) {
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == target) {
                *outRow = r;
                *outCol = c;
                return 1;       /* opuszcza OBIE pętle naraz */
            }
        }
    }
    return 0;
}

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    int row, col;

    if (findValue(grid, 7, &row, &col)) {
        printf("Znaleziono 7 w wierszu %d, kolumnie %d\n", row, col);
    } else {
        printf("7 nie ma w siatce\n");
    }

    return 0;
}

return zamyka wszystkie pętle w funkcji, nie potrzebuje flagi ani etykiety, a kod wyszukiwania ma teraz nazwę i można go testować osobno. Gdy zagnieżdżenie jest na tyle głębokie, że wyjście z niego sprawia kłopot, często jest to wskazówka, że ten blok i tak chciał być funkcją.

Kiedy pomagają, a kiedy szkodzą

break i continue zasługują na swoje miejsce, gdy pozwalają pętli powiedzieć "ten przypadek jest załatwiony" raz, blisko początku, zamiast owijać całe ciało w if. Porównaj:

/* z continue: właściwa praca nie jest wcięta */
for (int i = 0; i < n; i++) {
    if (!isValid(a[i])) continue;
    if (isDuplicate(a[i])) continue;
    process(a[i]);
}

/* bez niego: każdy warunek ochronny dodaje poziom */
for (int i = 0; i < n; i++) {
    if (isValid(a[i])) {
        if (!isDuplicate(a[i])) {
            process(a[i]);
        }
    }
}

Szkodzą, gdy jest ich dużo. Pętla z pięcioma rozrzuconymi break i trzema continue ma warunek wyjścia, który nigdzie nie jest zapisany: czytelnik musi przesymulować całe ciało, żeby wiedzieć, kiedy się zatrzyma. Dwie zasady, które dobrze się sprawdzają: trzymaj warunki z continue razem na początku ciała, a jeśli pętla ma więcej niż jeden czy dwa break, zastanów się, czy tej pracy nie powinien wykonywać warunek w nagłówku.

Dwie mniejsze pułapki. continue w do-while skacze do sprawdzenia na dole, które i tak jest następne: nieszkodliwe, ale zaskakuje. A break poza jakąkolwiek pętlą czy switch to błąd kompilacji, czyli jedyna pomyłka z tej strony, którą kompilator wyłapie za ciebie.

Najczęściej zadawane pytania

Jaka jest różnica między break a continue w C?

break całkowicie kończy pętlę i wykonanie wraca za nią. continue porzuca tylko bieżący obieg i przechodzi do następnego: w pętli for do części aktualizującej, a w while i do-while od razu do sprawdzenia warunku.

Jak wyjść z zagnieżdżonej pętli w C?

Pojedynczy break opuszcza tylko najbardziej wewnętrzną pętlę. Żeby wyjść z obu, ustaw flagę i sprawdzaj ją w warunku pętli zewnętrznej, użyj goto, by skoczyć do etykiety za pętlami, albo, co zwykle jest najczystsze, przenieś pętle do funkcji i użyj return.

Czy break wychodzi z pętli, czy tylko ze switch?

Z tego, co otacza go najbliżej. break wewnątrz switch, który jest w pętli, kończy tylko switch; pętla działa dalej. Żeby opuścić pętlę z wnętrza switch, potrzebujesz flagi, goto albo return.

Dlaczego continue powoduje nieskończoną pętlę while?

Bo continue skacze do warunku i pomija resztę ciała, łącznie z inkrementacją licznika, jeśli stoi na końcu. W pętli for aktualizacja jest w nagłówku, więc wykonuje się zawsze; w pętli while przenieś aktualizację przed continue albo użyj for.

Powiązane zagadnienia