C 语言 break 和 continue：用法与适用场景

改变循环流程的两种方式

循环的条件决定它何时结束，但有时真正的答案出现在循环体中间。你在数组里查找某个元素，第三个就找到了，何必再检查剩下的 997 个？又或者你在处理一个列表，其中一项是空的：跳过它，继续处理。

C 语言为这两种情况各准备了一个关键字：

• break：立即离开循环。程序从循环之后的第一条语句继续执行。
• continue：只放弃这一轮，进入下一轮。

#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;
}

第一个循环打印 1 2 3 4 后就停止了。第二个打印 1 2 3 4 6 7 8 9 10：它跳过了一个值，然后继续执行。

循环中的 break

最典型的用法是一找到目标就停止的查找：

#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;
}

因为 found 在 break 之前就被赋值了，循环之后的代码可以区分“找到了”和“元素都查完了”这两种情况。结果变量加 break 的组合，就是 C 语言中标准的查找写法。如果循环计数器是在循环头里声明的，循环结束后就不能再用它，因为它在右花括号处就离开了作用域。

break 每次只跳出一层：离它最近的 for、while、do-while 或 switch。

循环中的 continue

continue 用于那些应该跳过、但不应该中止整个处理的元素：

#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;
}

continue 跳到哪里，取决于循环的类型：

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

这个区别很实际。在 for 循环中，continue 永远不会跳过计数器自增，因为自增写在循环头里。在 while 循环中却会：

/* 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++;
}

要么把 i++ 移到 continue 之前，要么改写成 for 循环，循环头的结构让你不可能写错。

switch 中的 break 不会跳出循环

break 结束的是离它最近的循环或 switch，看哪个更近。把 switch 放进循环里，switch 中的每个 break 都属于 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;
}

q 命令打印了它的消息，但循环继续处理了 cc。如果“退出”本应结束循环，这个 break 并没有做到。解决办法有三种：标志变量、goto，或者把循环移到函数里用 return，下面会一一演示。

跳出嵌套循环

一个 break 只跳出一层。在两层嵌套循环中，它只结束内层循环，外层循环会像什么都没发生一样开始下一轮。

#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 语言没有 break 2，也没有带标签的 break。有三种正当的做法：

标志变量。 可移植，一目了然，只是稍显啰嗦：

#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;
}

代价是标志变量要出现在两个地方：外层条件和赋值处。嵌套到三层时，这种写法就真的很难受了。

goto。 C 语言中饱受诟病的跳转语句，而这正是有经验的 C 程序员会理直气壮地使用它的场景：

#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 到循环之后的标签，效果和其他语言中带标签的 break 完全一样，只用一行，也不需要维护标志变量。goto 的坏名声来自向后跳转和跳进其他代码块中间，那些确实会让控制流难以阅读。从嵌套循环中向前跳出一次并不属于这种情况。Linux 内核在清理路径中也使用同样的模式。要有意识地、节制地使用它；别因为忌讳 goto，就写出一个用三个标志变量、更难读懂的替代方案。

函数加 return。 通常是最好的答案，因为一次查找值得拥有一个名字：

#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 会一次性退出函数中的所有循环，不需要标志变量，也不需要标签，而且查找代码现在有了名字，可以单独测试。当嵌套深到跳出它都成了问题时，这往往说明这段代码本来就该写成一个函数。

什么时候有帮助，什么时候有害

当 break 和 continue 能让循环在顶部一次性说明“这种情况处理完了”，而不必把整个循环体包进一个 if 时，它们就物有所值。对比一下：

/* 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]);
        }
    }
}

用得太多时，它们就有害了。一个散落着五个 break 和三个 continue 的循环，它的退出条件没有写在任何地方，读代码的人必须在脑中把整个循环体模拟一遍，才知道它什么时候停止。两条经得起考验的准则：把 continue 守卫语句集中放在循环体顶部；如果一个循环有一两个以上的 break，想一想循环头里的条件是不是本该承担这份工作。

还有两个小陷阱。在 do-while 中，continue 跳到底部的条件判断，而那本来就是接下来要执行的部分：无害，但常常让人意外。另外，在任何循环或 switch 之外使用 break 是编译错误，这是本文所有错误中唯一一个编译器能替你发现的。