return 语句

return 语句终止当前函数的执行，将控制权返回给调用者。对于有返回值的函数，return 后面跟表达式；对于 void 函数，return 可以不带表达式。return 是函数与外部世界交互的边界——它传递计算结果、报告执行状态、释放栈帧。

基本语法

return;                 /* void 函数 */
return 表达式;          /* 非 void 函数 */

/* 有返回值的函数 */
int add(int a, int b)
{
    return a + b;       /* 返回两数之和 */
}

/* void 函数 */
void print_hello(void)
{
    printf("Hello\n");
    return;             /* 可以省略 */
}

main 函数的返回值

main 函数的返回值被操作系统接收，作为程序的退出状态：

int main(void)
{
    if (error_occurred)
        return 1;       /* 异常退出 */
    
    return 0;           /* 正常退出 */
}

C99 之前，如果 main 执行到末尾没有 return，行为未定义。C99 规定：如果 main 函数执行到末尾没有遇到 return，等效于 return 0;。但显式写 return 0; 是更好的习惯。

标准定义了两个宏表示退出状态：

#include <stdlib.h>

return EXIT_SUCCESS;        /* 通常等于 0 */
return EXIT_FAILURE;        /* 通常等于 1 */

使用宏比硬编码数字更清晰：

#include <stdlib.h>

int main(void)
{
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL)
        return EXIT_FAILURE;
    
    /* 处理文件 */
    fclose(fp);
    return EXIT_SUCCESS;
}

多 return 点

函数中可以有多个 return，用于不同路径提前退出：

int divide(int a, int b, int *result)
{
    if (b == 0) {
        printf("Error: division by zero\n");
        return -1;        /* 错误路径 */
    }
    
    *result = a / b;
    return 0;               /* 成功路径 */
}

多 return 点让错误处理更扁平，避免了深层嵌套：

/* 多 return：扁平 */
int process(int x)
{
    if (x < 0) return -1;
    if (x == 0) return 0;
    if (x > 100) return 1;
    
    return do_work(x);
}

/* 单 return：嵌套 */
int process_nested(int x)
{
    int result;
    if (x >= 0) {
        if (x != 0) {
            if (x <= 100) {
                result = do_work(x);
            } else {
                result = 1;
            }
        } else {
            result = 0;
        }
    } else {
        result = -1;
    }
    return result;
}

多 return 通常更易读，但过多（超过 3-4 个）可能使流程难以跟踪。

返回值类型转换

return 的表达式的值会转换为函数声明的返回类型：

double calculate(int a, int b)
{
    return a / b;           /* int 除法结果转为 double */
                            /* 如果 a=5, b=2，返回 2.0 不是 2.5！ */
}

/* 正确 */
double calculate(int a, int b)
{
    return (double)a / b;   /* 浮点除法 */
}

返回指针的注意事项

函数返回指针时，必须确保指向的内存仍然有效：

/* 错误：返回局部变量地址 */
int *get_value(void)
{
    int local = 10;
    return &local;          /* 危险：local 在函数返回后销毁 */
}

/* 正确：返回静态变量地址 */
int *get_counter(void)
{
    static int count = 0;   /* 静态存储期 */
    count++;
    return &count;          /* 安全 */
}

/* 正确：返回动态分配内存 */
int *create_array(int n)
{
    int *arr = malloc(n * sizeof(int));
    return arr;             /* 调用者负责 free */
}

/* 正确：返回传入的指针 */
char *trim(char *str)
{
    /* 修改并返回 str */
    return str;
}

无返回值的函数

void 函数可以省略 return：

void print_array(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    /* 隐式 return */
}

显式 return 用于提前退出：

void process(int arr[], int n)
{
    if (n <= 0)
        return;             /* 空数组，无需处理 */
    
    for (int i = 0; i < n; i++)
        arr[i] *= 2;
}

常见错误

void 函数返回表达式：

void set_value(int x)
{
    return x;               /* 错误：void 函数不能返回值 */
}

/* 正确 */
void set_value(int x)
{
    global = x;
    return;                 /* 或省略 */
}

非 void 函数缺少 return：

int get_value(int x)
{
    if (x > 0)
        return x;
    /* 错误：x <= 0 时没有 return */
}

/* 正确 */
int get_value(int x)
{
    if (x > 0)
        return x;
    return 0;               /* 所有路径都有 return */
}

C99 之前，控制流到达非 void 函数末尾而没有 return 是未定义行为。现代编译器会警告"control reaches end of non-void function"。

返回局部数组：

char *get_string(void)
{
    char str[] = "Hello";   /* 局部数组 */
    return str;             /* 危险：str 在函数返回后失效 */
}

/* 正确 */
char *get_string(void)
{
    static char str[] = "Hello";    /* 静态 */
    return str;
}

/* 或 */
char *get_string(void)
{
    char *str = malloc(6);
    strcpy(str, "Hello");
    return str;             /* 调用者 free */
}

最佳实践

所有控制路径都有 return（非 void 函数）
使用 EXIT_SUCCESS 和 EXIT_FAILURE 而非 0 和 1
main 函数显式写 return 0;
返回指针时确保内存有效（静态、动态分配、传入参数）
多 return 点让错误处理扁平化，但不宜过多
复杂清理逻辑用 goto 或 do-while(0) 集中到函数末尾