goto 语句

goto 语句无条件跳转到程序中标记的位置。它是 C 语言中最具争议的流程控制语句——滥用 goto 会破坏代码的结构化，使程序难以理解和维护；但在特定场景下（如深层嵌套中的集中错误处理），goto 可以简化代码、减少重复。C 语言保留了 goto，但建议谨慎使用。

基本语法

goto 标签;

/* ... */

标签: 语句

int i = 0;

loop:
    printf("%d\n", i);
    i++;
    if (i < 5)
        goto loop;

标签的命名规则与变量相同，后面跟冒号 :。标签有自己的名字空间，不会与变量名冲突。

适用场景

集中错误处理：

在函数中有多处可能出错，需要统一清理资源时，goto 比多层嵌套的 if 更清晰：

int process_file(const char *filename)
{
    FILE *fp = fopen(filename, "r");
    if (fp == NULL)
        goto error_open;
    
    char *buffer = malloc(1024);
    if (buffer == NULL)
        goto error_malloc;
    
    int *data = malloc(100 * sizeof(int));
    if (data == NULL)
        goto error_data;
    
    /* 主逻辑 */
    while (fgets(buffer, 1024, fp) != NULL) {
        /* 处理数据 */
    }
    
    /* 成功：清理并返回 */
    free(data);
    free(buffer);
    fclose(fp);
    return 0;

error_data:
    free(buffer);
error_malloc:
    fclose(fp);
error_open:
    perror("Error");
    return -1;
}

没有 goto 的等效代码需要重复清理逻辑：

int process_file(const char *filename)
{
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) {
        perror("Error");
        return -1;
    }
    
    char *buffer = malloc(1024);
    if (buffer == NULL) {
        fclose(fp);         /* 重复 */
        perror("Error");
        return -1;
    }
    
    int *data = malloc(100 * sizeof(int));
    if (data == NULL) {
        free(buffer);       /* 重复 */
        fclose(fp);         /* 重复 */
        perror("Error");
        return -1;
    }
    
    /* ... */
    
    free(data);
    free(buffer);
    fclose(fp);
    return 0;
}

goto 将错误处理集中到函数末尾，避免了清理代码的重复。

跳出深层嵌套：

for (...) {
    for (...) {
        for (...) {
            if (error_condition)
                goto cleanup;   /* 跳出三层循环 */
        }
    }
}

cleanup:
    /* 统一清理 */

禁止滥用

以下用法被认为是滥用 goto，应避免：

构造循环：

/* 不要用 goto 构造循环 */
int i = 0;
loop:
    printf("%d\n", i);
    i++;
    if (i < 10)
        goto loop;

/* 用 for */
for (int i = 0; i < 10; i++)
    printf("%d\n", i);

跳过代码块：

/* 不要用 goto 跳过初始化 */
goto skip;
int x = 10;                 /* 被跳过 */
skip:
    printf("Skipped\n");

C99 不允许 goto 跳过变长数组的初始化，但跳过普通变量的初始化是合法的（结果是未初始化）。

向上跳转形成复杂控制流：

/* 混乱的控制流 */
if (a) goto L1;
if (b) goto L2;
L1: /* ... */
if (c) goto L3;
L2: /* ... */
L3: /* ... */

这种"意大利面条式"代码是 goto 被诟病的原因。

限制

goto 不能跳转到其他函数：

void func1(void)
{
    goto label;             /* 错误：label 在另一个函数中 */
}

void func2(void)
{
label:
    /* ... */
}

goto 不能跳过变长数组（VLA）的声明进入其作用域：

{
    goto skip;              /* 错误：不能跳过 VLA */
    int n = 10;
    int arr[n];             /* VLA */
skip:
    /* ... */
}

现代替代方案

许多 goto 的使用场景可以用结构化方式替代：

goto 场景	替代方案
循环	`for`、`while`、`do-while`
条件分支	`if-else`、`switch`
跳出多层循环	标志变量、提取函数
集中错误处理	`do { ... } while(0)` + `break`、提取函数

/* 用 do-while(0) 替代 goto 进行错误处理 */
int process_file(const char *filename)
{
    FILE *fp = NULL;
    char *buffer = NULL;
    int *data = NULL;
    int result = -1;
    
    do {
        fp = fopen(filename, "r");
        if (fp == NULL) break;
        
        buffer = malloc(1024);
        if (buffer == NULL) break;
        
        data = malloc(100 * sizeof(int));
        if (data == NULL) break;
        
        /* 主逻辑 */
        result = 0;
    } while (0);
    
    /* 统一清理 */
    free(data);
    free(buffer);
    if (fp) fclose(fp);
    
    if (result != 0)
        perror("Error");
    
    return result;
}

do { ... } while(0) 配合 break 是 Linux 内核等代码中常见的模式，它提供了类似 goto 的集中退出点，但保持了结构化。

最佳实践

优先使用 for、while、if、switch 等结构化控制流
goto 仅在集中错误处理、跳出深层嵌套时使用
goto 的目标标签放在函数末尾，用于清理和返回
不要向上跳转（向后跳）
不要跳过变量初始化
不要构造循环
标签名应清晰表达目的，如 cleanup、error_handler