Break dan Continue di C: Cara Kerja dan Kapan Memakainya

Dua Cara Mengubah Alur Loop

Kondisi loop menentukan kapan loop berakhir, tetapi kadang jawaban sebenarnya muncul di tengah body. Kamu mencari sesuatu di array dan menemukannya di elemen ketiga, jadi buat apa memeriksa 997 elemen lainnya? Atau kamu memproses sebuah list dan satu entrinya kosong: lewati saja dan lanjutkan.

C punya satu kata kunci untuk masing-masing kasus:

• break: keluar dari loop sekarang. Eksekusi berlanjut ke pernyataan pertama setelah loop.
• continue: tinggalkan putaran ini saja. Lanjut ke putaran berikutnya.

#include <stdio.h>

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

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

    return 0;
}

Loop pertama mencetak 1 2 3 4 lalu berhenti. Loop kedua mencetak 1 2 3 4 6 7 8 9 10: ia melewati satu nilai dan terus berjalan.

break di Dalam Loop

Pemakaian yang paling umum adalah pencarian yang berhenti begitu berhasil:

#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;              /* no reason to look at the rest */
        }
    }

    if (found >= 0) {
        printf("Found %d at index %d\n", target, found);
    } else {
        printf("%d is not in the array\n", target);
    }

    return 0;
}

Karena found diisi sebelum break, kode setelah loop bisa membedakan "ketemu" dan "elemennya habis". Pasangan itu, variabel hasil ditambah break, adalah pola pencarian standar di C. Counter loop-nya sendiri tidak bisa dipakai setelahnya kalau dideklarasikan di header, karena ia keluar dari scope di kurung kurawal penutup.

break selalu keluar dari satu loop saja: for, while, do-while, atau switch terdekat yang membungkusnya.

continue di Dalam Loop

continue dipakai untuk entri yang harus dilewati, bukan untuk menghentikan pekerjaan:

#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;           /* ignore zero and negatives */
        }
        sum += values[i];
        counted++;
    }

    printf("Sum of %d positive values: %d\n", counted, sum);
    return 0;
}

Ke mana continue melompat tergantung jenis loop-nya:

for        -> the update part of the header (so the counter still advances)
while      -> the condition test (nothing else in the body runs)
do-while   -> the condition test at the bottom

Perbedaan itu bukan sekadar teori. Di loop for, continue tidak akan pernah melewati penambahan counter, karena penambahannya ada di header. Di loop while, itu bisa terjadi:

/* BUG: continue skips i++, so this hangs at the first even number */
int i = 0;
while (i < 10) {
    if (i % 2 == 0) {
        continue;
    }
    printf("%d ", i);
    i++;
}

Pindahkan i++ ke atas continue, atau tulis sebagai loop for, di mana header-nya membuat kesalahan ini mustahil terjadi.

break di Dalam switch Bukan break untuk Loop

break mengakhiri loop atau switch terdekat yang membungkusnya, mana pun yang lebih dekat. Taruh switch di dalam loop, maka setiap break di dalamnya milik switch:

#include <stdio.h>

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

    for (int i = 0; commands[i] != '\0'; i++) {
        switch (commands[i]) {
            case 'a':
                printf("add\n");
                break;          /* ends the switch; the loop continues */
            case 'b':
                printf("back\n");
                break;
            case 'q':
                printf("quit requested\n");
                break;          /* also only the switch! */
            default:
                printf("unknown: %c\n", commands[i]);
                break;
        }
    }

    printf("loop finished\n");
    return 0;
}

Perintah q mencetak pesannya dan loop terus berjalan sampai cc. Kalau keluar seharusnya mengakhiri loop, break itu tidak melakukannya. Perbaikannya adalah flag, goto, atau memindahkan loop ke sebuah fungsi dan memakai return. Semuanya ditunjukkan di bawah.

Keluar dari Nested Loop

Satu break hanya keluar satu tingkat. Di dalam dua loop bersarang, ia hanya mengakhiri loop dalam, dan loop luar memulai putaran berikutnya seolah tidak terjadi apa-apa.

#include <stdio.h>

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

    /* break leaves only the inner loop - the outer keeps going */
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("inner break at row %d\n", r);
                break;
            }
        }
    }
    printf("(the outer loop ran all 3 rows)\n");
    return 0;
}

C tidak punya break 2 dan tidak punya break berlabel. Ada tiga pilihan yang jujur:

Flag. Portabel, jelas, dan sedikit ramai:

#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("Found 7 at row %d, column %d\n", r, c);
                found = 1;
                break;
            }
        }
    }

    return 0;
}

Flag muncul di dua tempat, yaitu kondisi loop luar dan assignment-nya, dan itulah harganya. Dengan tiga tingkat nesting, ini jadi benar-benar tidak enak.

goto. Lompatan C yang sering dicela, dan inilah satu-satunya kasus di mana programmer C berpengalaman memakainya tanpa merasa bersalah:

#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("Found 7 at row %d, column %d\n", r, c);
                goto done;
            }
        }
    }
    printf("not found\n");

done:
    printf("search finished\n");
    return 0;
}

goto maju ke label tepat setelah loop melakukan persis apa yang dilakukan break berlabel di bahasa lain, dalam satu baris dan tanpa flag yang harus dijaga agar tetap sinkron. Reputasi buruk goto berasal dari lompatan mundur dan lompatan ke tengah blok lain, yang memang menghasilkan alur kontrol yang sulit dibaca. Satu lompatan maju keluar dari nested loop tidak termasuk itu. Kernel Linux memakai pola yang sama untuk jalur cleanup. Gunakan dengan sengaja dan secukupnya; jangan biarkan tabu itu mendorongmu ke alternatif tiga flag yang lebih sulit dibaca.

Fungsi dan return. Biasanya jawaban terbaik, karena sebuah pencarian layak punya nama:

#include <stdio.h>

/* returns 1 and writes the position when found, 0 otherwise */
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;       /* leaves BOTH loops at once */
            }
        }
    }
    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("Found 7 at row %d, column %d\n", row, col);
    } else {
        printf("7 is not in the grid\n");
    }

    return 0;
}

return keluar dari setiap loop di fungsi itu, tidak butuh flag maupun label, dan kode pencariannya sekarang punya nama dan bisa diuji tersendiri. Kalau nesting-nya sudah begitu dalam sampai keluar darinya jadi masalah, sering kali itu tanda bahwa blok tersebut memang sebaiknya menjadi fungsi.

Kapan Membantu, dan Kapan Merugikan

break dan continue berguna ketika keduanya membuat loop bisa bilang "kasus ini selesai" sekali saja, di dekat bagian atas, alih-alih membungkus seluruh body dengan if. Bandingkan:

/* with continue: the real work is not indented */
for (int i = 0; i < n; i++) {
    if (!isValid(a[i])) continue;
    if (isDuplicate(a[i])) continue;
    process(a[i]);
}

/* without: every guard adds a level */
for (int i = 0; i < n; i++) {
    if (isValid(a[i])) {
        if (!isDuplicate(a[i])) {
            process(a[i]);
        }
    }
}

Keduanya merugikan kalau jumlahnya banyak. Loop dengan lima break dan tiga continue yang tersebar punya kondisi keluar yang tidak tertulis di mana pun: pembaca harus mensimulasikan seluruh body untuk tahu kapan loop berhenti. Dua pedoman yang terbukti bagus: kumpulkan pengecekan continue di bagian atas body, dan kalau sebuah loop punya lebih dari satu atau dua break, pertimbangkan apakah kondisi di header seharusnya mengerjakan tugas itu.

Ada dua jebakan kecil. continue di do-while melompat ke pengecekan di bagian bawah, yang memang langkah berikutnya: tidak berbahaya, tetapi sering mengejutkan. Lalu break di luar loop atau switch adalah error kompilasi, satu-satunya kesalahan di sini yang ditangkap compiler untukmu.