函数在 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 一样,但四个变量的地址各不相同。

课件说形参"不会向内存申请空间",这句要分两半听。函数只是定义、还没被调用时,形参确实不占内存,它只是原型上的占位符;一旦发生调用,每个形参都要在栈上分配空间装实参的值,这个过程叫形参的实例化。所以"形式上存在"描述的是没被调用的那段时间,不是"永远不占空间"。
想让函数改到调用者的变量,只能把地址递进去:
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); /* 声明:只说长相,不带函数体 */声明只需要返回类型、函数名和参数类型,参数名可以省。定义是带函数体的那一份,它本身也是一次声明,所以把定义放在调用之前就不用再单独写声明。
多文件工程就是按这条规则组织的:声明进头文件,定义进源文件,用到处包含头文件。

这条规则在今天更硬:C99 删除了隐式函数声明,调用一个没有声明的函数不再"默认返回 int",而是直接报错。MSVC 偶尔先给警告,让人误以为还能跑。
static 改的是存储期或链接属性
先分清两个词。作用域决定"名字在源码的哪些行能用";生命周期决定"变量从什么时候存在到什么时候消失"。
static 修饰局部变量,改的是生命周期:
void test(void)
{
static int i = 0; /* 只初始化一次 */
i++;
printf("%d ", i);
}连调五次,输出 1 2 3 4 5。因为 i 的存储位置从栈搬到了静态区,函数返回时不清毁,下次进来接着上次的值算。但作用域一点没变——出了函数仍然看不见它。

static 修饰全局变量或函数,改的是链接属性:
/* add.c */
static int g_val = 2018;
/* test.c */
extern int g_val; /* 声明了也没用,链接阶段找不到 */全局变量默认是外部链接,别的源文件 extern 声明一下就能用。加了 static,它变成内部链接,只在本翻译单元可见,别的文件再声明也链接不上。修饰函数同理。
extern 本身不创造对象,它只声明"这个符号在别处有定义"。所以 extern 和 static 不是一对反义词:前者管"我要用别人的",后者管"我的不外借"。
课件说"全局变量的作用域是整个工程",这句话不准确。全局变量的作用域是它所在的那个源文件;它能被别的文件使用,靠的是外部链接属性加一份声明,不是作用域跨了文件。这个区别在排查 LNK2019(无法解析的外部符号)时很关键:链接器看的从来不是作用域,是符号的链接属性。
函数这一讲的内容看起来是七八个互不相关的语法点,其实都在回答同一个问题:这个名字在哪个位置、哪一层、以什么权限被看见。return 决定值怎么出来,形参决定值怎么进去,声明决定名字什么时候被看见,static 决定名字能被多少个文件看见。把这四条串起来,函数部分就没有需要死记的条目了。
还没有评论 — 第一条由你来留。