函数

为什么要把代码装进「函数」？

想象一家工厂把「切菜」「炒菜」「装盘」拆成三个工位：每个工位只做一件事，原料从上一个工位递过来，成品交给下一个。主程序如果把所有步骤写进 main，就像一个人包办全流程——代码越长越难改，改一处可能牵全身。

如果没有函数呢？ 重复逻辑只能复制粘贴，变量名容易冲突，团队协作也无法分工。函数把「一段可复用的加工步骤」打包命名：需要时调用，不需要时不用管内部细节。这一章教你 C 语言里函数怎么定义、怎么声明、怎么传参、怎么返回值，以及怎样用多个函数拼出模块化程序。

创建和使用函数：定义、原型与调用

函数定义 是函数的「完整档案」：

int sum(int a, int b)   /* 函数头 */
{
    return a + b;       /* 函数体 */
}

int 是返回类型，sum 是名字，(int a, int b) 是形参列表，花括号里是函数体。return 把结果交回给调用方。

若函数定义写在 main 之后，调用点之前的编译器还不知道 sum 长什么样——需要 函数原型（声明）：

int sum(int a, int b);  /* 原型：分号结尾，无函数体 */
 
int main(void) {
    int x = sum(3, 5);  /* 调用 */
    return 0;
}
 
int sum(int a, int b) { /* 定义 */
    return a + b;
}

原型是「名片」，定义是「车间」，调用是「下单」。编译器用原型检查 sum(3, 5) 类型是否匹配；链接器把调用绑到真正的定义上。

猜一猜：只有原型、没有定义，程序能通过链接吗？用 Stepper 看声明、定义、调用如何串起来。

void 作返回类型表示「无返回值」——函数体里用 return; 提前结束，或不写 return 落到函数末尾。

形参、实参与值传递

调用 sum(3, 5) 时，3 和 5 是 实参（actual argument）；定义里的 a、b 是 形参（formal parameter）。

C 对 int、double、char 以及结构体等，默认采用 值传递（pass by value）：

void try_change(int n) {
    n = 99;
}
 
int main(void) {
    int num = 5;
    try_change(num);
    printf("%d\n", num);  /* 仍是 5 */
    return 0;
}

函数内改 n 只改形参副本，main 里的 num 不动。要让函数改调用方的变量，需传指针（下一章）或把新值 return 回去。

返回值 常用赋值或表达式接收：int r = sum(3, 5); 或 printf("%d", sum(3, 5));。

调用记录：一次函数调用发生了什么

从 C 抽象机看，每次函数调用都有独立的参数与自动对象实例，并在返回后结束本次执行。常见 ABI 用 栈帧（stack frame） 表示这份调用记录，但优化器可以把参数和局部对象放入寄存器、消除对象，甚至内联整个调用。因此下图是理解调用关系的典型实现模型，不是可移植程序可以依赖的内存布局。

以 int result = add(5, 3); 为例：

局部变量、块作用域与自动存储期

局部变量 的名字属于 块作用域。形参的作用域覆盖整个函数定义；函数体内普通局部对象通常具有自动存储期，每次进入相应块都会产生新的对象实例：

int twice(int n);
 
int main(void) {
    int x = 10;        /* main 的局部变量 */
    printf("%d\n", twice(x));
    return 0;
}
 
int twice(int n) {     /* n 是 twice 的局部变量 */
    int tmp = n * 2;   /* tmp 也是 twice 的局部 */
    return tmp;
}

main 看不到 tmp，twice 也看不到 x，因为它们的块作用域不重叠。同名局部标识符在不同函数里互不影响；内层块还可以隐藏外层同名标识符。C 标准术语中的函数作用域只属于 label 标签，普通局部变量不是“函数作用域”。

函数内的 static 局部对象（static int count）具有静态存储期，生命周期贯穿整个程序，但名字仍只有块作用域；后续章节会展开。

递归：函数调用自身

递归（recursion） 把大问题拆成「同样结构的小一号问题」：

long fact(int n) {
    if (n <= 1)
        return 1;           /* 基准情形 */
    return n * fact(n - 1); /* 递归情形 */
}

fact(4) = 4 × fact(3) = 4 × 3 × fact(2) = … 直到 fact(1) 直接返回 1，再逐层乘回。

尾递归不是“自动省栈”承诺

当递归调用是返回前最后一个动作时，称为 尾递归（tail recursion）。把中间结果放进累加器，就能把阶乘写成尾递归：

static unsigned long fact_tail(unsigned n, unsigned long acc) {
    if (n <= 1)
        return acc;
    return fact_tail(n - 1, acc * n);
}
 
unsigned long fact(unsigned n) {
    return fact_tail(n, 1UL);
}

实现可以把尾调用复用为当前调用记录，但 C11 不保证尾调用优化；可移植程序不能因为“这是尾递归”就假定常量栈空间。若深度由不可信输入决定，循环通常更稳妥。无论递归还是循环，unsigned long 的阶乘都会很快溢出，生产代码还要在乘法前检查 acc > ULONG_MAX / n。

多源文件与头文件：从翻译单元到链接

较大的程序会把声明放进头文件，把定义分散到多个源文件。预处理后，每个 .c 文件连同它包含的头文件形成一个 翻译单元，再由链接器把目标文件组成程序。

/* math_utils.h */
#ifndef MATH_UTILS_H
#define MATH_UTILS_H
int square(int value);
#endif

/* math_utils.c */
#include "math_utils.h"
 
int square(int value) {
    return value * value;
}

/* main.c */
#include <stdio.h>
#include "math_utils.h"
 
int main(void) {
    printf("%d\n", square(7));
    return 0;
}

cc -std=c11 -Wall -Wextra -Wpedantic -c math_utils.c
cc -std=c11 -Wall -Wextra -Wpedantic -c main.c
cc main.o math_utils.o -o app

头文件保护宏允许同一声明被间接包含多次；函数定义留在一个 .c 文件中。声明告诉每个调用所在的翻译单元函数类型，定义提供最终可链接实体。具有外部链接的普通函数在整个程序中通常只能有一个定义：没有定义会产生未解析符号，重复定义会产生多重定义错误。

地址和指针：仍然是值传递

一元 & 运算符取得对象的地址，* 对指针做 间接访问。把地址作为实参，函数收到的仍然是指针值的副本，但副本和调用方指针指向同一对象，所以能修改该对象：

#include <stdio.h>
 
void swap(int *left, int *right) {
    int temp = *left;
    *left = *right;
    *right = temp;
}
 
int main(void) {
    int a = 3, b = 8;
    swap(&a, &b);
    printf("a=%d b=%d\n", a, b);
    return 0;
}

调用方用 &a、&b 提供有效地址，swap 用 *left、*right 间接访问对象。若接口允许空指针，函数必须在解引用前明确处理；本例的契约要求两个参数都指向有效 int。传指针没有改变 C 的值传递规则，只是被复制的值恰好是地址。

代码详解：模块化小工具

场景一：函数原型 + 定义 + 调用

#include <stdio.h>
 
double cube(double x);   /* 原型 */
 
int main(void) {
    printf("2^3 = %.0f\n", cube(2.0));
    return 0;
}
 
double cube(double x) {   /* 定义 */
    return x * x * x;
}

main 在前、定义在后时，原型不可省略。

场景二：多函数分工

#include <stdio.h>
 
int get_int(int *value);
int square(int n);
void greet(void);
 
int main(void) {
    int x;
    greet();
    if (!get_int(&x))
        return 1;
    printf("平方 = %d\n", square(x));
    return 0;
}
 
void greet(void) {
    printf("输入一个整数：");
}
 
int get_int(int *value) {
    return scanf("%d", value) == 1;
}
 
int square(int n) {
    return n * n;
}

每个函数一块职责：问候、读入、计算——main 只做调度。

场景三：值传递与返回值

#include <stdio.h>
 
int max_of_two(int a, int b) {
    if (a > b)
        return a;
    return b;
}
 
int main(void) {
    int m = max_of_two(12, 7);
    printf("较大者 %d\n", m);
    return 0;
}

形参 a、b 是实参的副本；return 把结果传回调用方，不修改 main 里原有变量。

场景四：递归求阶乘

#include <stdio.h>
 
unsigned long fact(unsigned n) {
    if (n <= 1)
        return 1UL;
    return n * fact(n - 1);
}
 
int main(void) {
    printf("4! = %ld\n", fact(4));
    return 0;
}

本例聚焦递归结构，并假设 4! 可由 unsigned long 表示。若 n 来自输入，调用前还要限制范围或在每次乘法前做溢出检查。

容易踩的坑

小结

• 函数 = 返回类型 + 名字 + 形参列表 + 体；原型供编译器检查，定义提供实现，链接器绑定调用
• 实参是调用时的值，形参是定义里的占位；C 默认值传递，改形参不改实参
• 每次调用有独立执行状态；栈帧是常见实现模型，不是所有局部对象的标准布局保证
• 普通局部变量具有块作用域；只有 label 标签具有 C 术语中的函数作用域
• 递归需基准情形与进展；尾调用优化不是 C11 保证
• 多源文件用头文件共享声明、源文件提供定义、链接器组合目标文件
• 传地址仍是值传递；被复制的指针可用于间接访问调用方对象

#include <stdio.h>
 
int main(void) {
    printf("面积 = %d\n", rect_area(5, 10));
    return 0;
}

#include <stdio.h>
 
int rect_area(int w, int h);   /* 原型 */
 
int main(void) {
    printf("面积 = %d\n", rect_area(5, 10));
    return 0;
}
 
int rect_area(int w, int h) {
    return w * h;
}

#include <stdio.h>
 
int is_prime(int n);
void print_primes(int limit);
 
int main(void) {
    int limit;
    printf("上限 = ");
    if (scanf("%d", &limit) != 1)
        return 1;
    print_primes(limit);
    return 0;
}
 
int is_prime(int n) {
    int i;
    if (n < 2)
        return 0;
    for (i = 2; i <= n / i; i++)
        if (n % i == 0)
            return 0;
    return 1;
}
 
void print_primes(int limit) {
    int i;
    for (i = 2; i <= limit; i++)
        if (is_prime(i))
            printf("%d ", i);
    printf("\n");
}

名词解释