函数在 C 里干两件事:把一段计算从主流程里切出去,让它能被反复调用;给这段计算一个名字,让编译器在别的地方也能找到它。这两件事拆开看很朴素,但一半的编译错误和链接错误都出在第二件上——名字什么时候可见、在哪个文件里可见。

库函数不属于这门语言

C 语言标准只规定语法和一批函数的行为,不提供实现。ANSI C 把常用函数写成规范,编译器厂商照着实现,这些成品就是库函数。printf、scanf 都是这个来路:它们不在语言里,只是每个编译器都得给。

库函数按功能分装在不同头文件里声明的。<stdio.h> 管输入输出,<string.h> 管字符串,<math.h> 管数学。用之前包含对应头文件不是形式主义,而是让编译器拿到函数原型:参数几个、各是什么类型、返回什么。

#include <stdio.h>
#include <math.h>
 
int main(void)
{
    double d = 16.0;
    double r = sqrt(d);
 
    printf("%lf\n", r);      /* 4.000000 */
    return 0;
}

double sqrt(double x); 这一行信息量很足:sqrt 是函数名,括号里的 double x 说明调用时必须给一个 double,最左边的 double 说明结果也是 double。查一个新函数,看四样东西就够:原型、功能、参数与返回值含义、一段能跑的示例。cppreference 的每个函数页基本都按这个顺序排。

不包含头文件会怎样?课件里写的是"可能会出现一些问题",这个说法放在今天偏轻。C99 已经删掉了隐式函数声明,GCC 从 14 起把"调用未声明函数"直接当错误处理,MSVC 也只会先给个警告然后按 int 返回值处理。数学库还多一层:Linux 上 sqrt 在 libm 里,编译要加 -lm,否则链接阶段才报 undefined reference。

顺带一处课件的笔误:示例里写的是 #include <stido.h>,正确拼写是 stdio.h;后面声明函数时还用了中文全角分号 ;,编译器不认。照抄这两处会直接编译失败。

一个函数由四个格子组成

ret_type fun_name(形式参数)
{
    /* 函数体 */
}

ret_type 是返回类型,不返回东西就写 void;fun_name 是名字,起名要能看出它在干什么;括号里交代参数的类型、名字和个数,没有参数写 void;花括号里是计算过程。

int Add(int x, int y)
{
    return x + y;
}

这段加法函数里没有临时变量,因为 return 后面可以直接跟表达式。写成 int z = x + y; return z; 完全等价,只是多了一个变量。

形参是实参的一份拷贝,这是 C 唯一的传参方式

void Swap(int x, int y)
{
    int temp = x;
    x = y;
    y = temp;
}
 
int main(void)
{
    int a = 10, b = 20;
    Swap(a, b);
    printf("%d %d\n", a, b);     /* 还是 10 20 */
}

Swap 内部确实把两个值换了个位置,main 里却一点没变。原因不复杂:调用 Swap(a, b) 时,a、b 的值被复制进 x、y,函数改的是那两份副本。C 没有引用传递,只有值传递。

调试器里能直接看到这件事:x、y 的值和 a、b 一样,但四个变量的地址各不相同。

监视窗口里 a、b 与 x、y 的值相同、地址不同:形参是调用发生时在栈上新开的一份拷贝

课件说形参"不会向内存申请空间",这句要分两半听。函数只是定义、还没被调用时,形参确实不占内存,它只是原型上的占位符;一旦发生调用,每个形参都要在栈上分配空间装实参的值,这个过程叫形参的实例化。所以"形式上存在"描述的是没被调用的那段时间,不是"永远不占空间"。

想让函数改到调用者的变量,只能把地址递进去:

void Swap(int *x, int *y)
{
    int temp = *x;
    *x = *y;
    *y = temp;
}

此时传参仍然是值传递——复制的是地址这个值。指针在这里不是技巧,它是"改原件"的唯一入口。

return 的规则比想象中细

  • return 表达式; 先求值,再按赋值规则转换成函数返回类型。return 3.7; 放进 int 函数,返回的是 3。
  • return; 什么都不返回,只能用在返回类型为 void 的函数里。
  • return 一执行,函数立刻结束,后面的语句不会跑。
  • 返回类型写了,但函数一条 return 都没有,调用者拿到的值是未定义的。

课件里有两句需要更新。

第一句是"函数中存在 if 等分支时,必须保证每种情况都有 return,否则会出现编译错误"。实际编译器的反应通常只是警告:MSVC 给 C4715,GCC 给 -Wreturn-type。它之所以危险,是因为被漏掉的那条路径返回了不确定的值,调用者一旦使用就是未定义行为。这不是"编译器帮你拦住了",而是"编译器提醒了,但代码仍然编得出来"。

第二句是"返回类型不写,编译器默认是 int"。这是 C89 的旧规则,C99 已经删除隐式 int,C23 更明确禁止。今天的代码里不写返回类型就是错误,不能算"默认 int"。

main 有一个特殊待遇:C99 起,执行到末尾的 } 等价于 return 0;。别的函数没有这个豁免。

数组做参数,传的是首地址

#include <stdio.h>
 
void set_arr(int arr[], int sz)
{
    for (int i = 0; i < sz; i++)
        arr[i] = -1;
}
 
void print_arr(int arr[], int sz)
{
    for (int i = 0; i < sz; i++)
        printf("%d ", arr[i]);
    printf("\n");
}
 
int main(void)
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sz = sizeof(arr) / sizeof(arr[0]);
 
    set_arr(arr, sz);
    print_arr(arr, sz);      /* -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 */
    return 0;
}

这里出现了和前面不一样的地方:数组不会被整块复制。形参写成 int arr[],编译器实际按 int *arr 处理,方括号里的长度写了也被忽略,传过去的是首元素地址。于是函数内部的 sizeof(arr) 得到的是指针大小(64 位下 8 字节),不是数组的字节数。长度必须单独传——这就是 sz 存在的原因,也是 sizeof(arr) / sizeof(arr[0]) 只能在数组还没退化的地方使用的原因。

几条相关规则一起记:

  • 形参是一维数组时,数组大小可以省略。
  • 形参是二维数组时,行数可以省略,列数不能省,void f(int a[][5]) 才对;编译器要靠列数算 a[i][j] 的偏移。
  • 形参不创建新数组,函数里操作的数组和调用者的数组是同一块内存。

课件在这一节的示例里,main 直接调用了还没声明的 set_arr、print_arr。按下一节的规则,这种写法在 C99 之后编不过。示例想演示的是传参形式,但顺序确实写错了。

嵌套调用与链式访问

函数可以互相调用,最典型的是把"闰年判断"抽出来给"求某月天数"用:

int is_leap_year(int y)
{
    return ((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0);
}
 
int get_days_of_month(int y, int m)
{
    int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    int day = days[m];
 
    if (is_leap_year(y) && m == 2)
        day += 1;
    return day;
}

main 调 get_days_of_month,它再调 is_leap_year,这就是嵌套调用。注意"嵌套调用"和"嵌套定义"是两件事:C 不允许在一个函数体里再定义另一个函数,函数只能平铺在文件作用域里定义。

链式访问是把一个函数的返回值直接当另一个函数的实参:

printf("%d\n", strlen("abcdef"));

printf 自己也有返回值:它返回实际输出的字符数。所以

printf("%d", printf("%d", printf("%d", 43)));

从里往外算:最内层输出 43,返回 2;中间那层输出 2,返回 1;最外层输出 1,屏幕上是 4321。这段代码没有实用价值,但它说明函数调用本身就是一个值,可以被外层继续使用。

声明让名字先被看见

编译器按翻译单元从第一行往下扫,不回头。把函数定义写在调用之后:

#include <stdio.h>
 
int main(void)
{
    int y = 0;
    scanf("%d", &y);
    int r = is_leap_year(y);      /* 此时还没见过这个名字 */
    printf("%d\n", r);
    return 0;
}
 
int is_leap_year(int y)
{
    return ((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0);
}

老编译器会给 C4013: 'is_leap_year' undefined; assuming extern returning int,再往下看到真正的定义又给一条 C2371 类型冲突。两条报错是同一个原因:调用点在声明之前。

课件把这句解释成"没有发现前面有 is_leap_year 的定义",这里要改一个字——编译器找的是声明,不是定义。函数定义完全可以在另一个 .c 文件里,只要调用点之前见过声明:

int is_leap_year(int y);      /* 声明:只说长相,不带函数体 */

声明只需要返回类型、函数名和参数类型,参数名可以省。定义是带函数体的那一份,它本身也是一次声明,所以把定义放在调用之前就不用再单独写声明。

多文件工程就是按这条规则组织的:声明进头文件,定义进源文件,用到处包含头文件。

同一个工程里 add.h 只有声明、add.c 只有定义、test.c 包含头文件后调用:链接器要求的是符号,编译器要求的是声明

这条规则在今天更硬:C99 删除了隐式函数声明,调用一个没有声明的函数不再"默认返回 int",而是直接报错。MSVC 偶尔先给警告,让人误以为还能跑。

static 改的是存储期或链接属性

先分清两个词。作用域决定"名字在源码的哪些行能用";生命周期决定"变量从什么时候存在到什么时候消失"。

static 修饰局部变量,改的是生命周期:

void test(void)
{
    static int i = 0;     /* 只初始化一次 */
    i++;
    printf("%d ", i);
}

连调五次,输出 1 2 3 4 5。因为 i 的存储位置从栈搬到了静态区,函数返回时不清毁,下次进来接着上次的值算。但作用域一点没变——出了函数仍然看不见它。

两个 test 函数的变量落在不同区域:普通局部变量在栈上随函数进出,static 局部变量在静态区,和全局变量一样活到程序结束

static 修饰全局变量或函数,改的是链接属性:

/* add.c */
static int g_val = 2018;
 
/* test.c */
extern int g_val;            /* 声明了也没用,链接阶段找不到 */

全局变量默认是外部链接,别的源文件 extern 声明一下就能用。加了 static,它变成内部链接,只在本翻译单元可见,别的文件再声明也链接不上。修饰函数同理。

extern 本身不创造对象,它只声明"这个符号在别处有定义"。所以 extern 和 static 不是一对反义词:前者管"我要用别人的",后者管"我的不外借"。

课件说"全局变量的作用域是整个工程",这句话不准确。全局变量的作用域是它所在的那个源文件;它能被别的文件使用,靠的是外部链接属性加一份声明,不是作用域跨了文件。这个区别在排查 LNK2019(无法解析的外部符号)时很关键:链接器看的从来不是作用域,是符号的链接属性。


函数这一讲的内容看起来是七八个互不相关的语法点,其实都在回答同一个问题:这个名字在哪个位置、哪一层、以什么权限被看见。return 决定值怎么出来,形参决定值怎么进去,声明决定名字什么时候被看见,static 决定名字能被多少个文件看见。把这四条串起来,函数部分就没有需要死记的条目了。