写函数笔记写到第五篇了。前几篇从 printf 为什么要带 stdio.h 讲起一路聊到参数传递、数组传参、猜数字游戏的项目拆解基本把 C 语言函数的“日常用法”过了一遍。但函数这关真正的分水岭不在“会用”而在“想明白”声明跟定义到底差在哪递归为什么既能轻松搞定归并排序、又能在几秒钟之内把调用栈塞满导致崩溃作用域又是怎么决定一个变量“活不活”“能不能被看见”的。这篇笔记把三个核心关键词一次讲透C 语言函数、递归、作用域。这篇内容适合两类人。一类是刚学完循环和数组、准备用函数去拆解项目的新手另一类是已经能写出不少代码但项目稍微变大就遇到“函数未声明”“全局变量到处被改”这类问题的同学。建议看的时候把自己代入一个场景你手里只有一个 main.c 文件所有问题都能在这个文件里复现我尽量把这个过程完整还原出来。1. 函数基础里最容易踩坑的三个细节1.1 声明与定义编译器是“一心往前看”的初学者最喜欢把 main 函数写在最前面然后在 main 里调用了一个后面才定义的函数。比如#include stdio.h int main(void) { int a 3, b 5; int r add(a, b); // 这里编译器还没见过 add 的完整定义 printf(%d\n, r); return 0; } int add(int x, int y) { return x y; }这份代码在 C89 标准下能编译过但会收到一条“隐式声明”的警告在 C99 及以后的标准里编译器基本会直接报错或者给出致命警告。原因是 C 编译器处理代码是顺序扫描的当它停在add(a, b);这一行时如果前面既没见过add的函数定义也没见过add的函数原型它根本不知道add的返回值是什么类型、参数该接收几个只能默认按照“返回 int、参数个数不检查”的方式去生成代码。到了链接阶段如果add的定义在整个工程里都不存在才会报“未定义引用”。所以解决问题的思路也很清晰。要么把add的定义挪到 main 之前要么在调用之前写上函数原型也叫函数声明int add(int x, int y); // 函数声明分号结尾不是完整定义 int main(void) { int r add(3, 5); return 0; } int add(int x, int y) { return x y; }我见过不少同学在一个 2000 行的大文件里把所有函数定义全堆在 main 前面结果文件顶部几十个函数挤在一起阅读体验极差。正确的工程习惯是把函数声明放进头文件源文件只放函数定义main 里按业务逻辑调用。这样不仅编译顺序好解决还能让代码像目录一样清晰。1.2 参数传递值传递、地址传递、数组传参要分开记参数传递是函数满天飞之后最容易被搞混的概念。C 语言里函数参数默认是值传递函数体内拿到的只是实参的一份拷贝你在函数内部怎么改这个拷贝都不会影响调用方的变量。一个最经典的失败例子#include stdio.h void swap_wrong(int a, int b) { int tmp a; a b; b tmp; } int main(void) { int x 3, y 5; swap_wrong(x, y); printf(%d %d\n, x, y); // 输出 3 5交换失败 return 0; }想要让函数内部修改外部变量必须传递地址指针void swap_right(int *a, int *b) { int tmp *a; *a *b; *b tmp; } swap_right(x, y);这里我要额外强调一种看起来像“传引用”的假象数组传参。数组名作为参数传给函数时并不会把整个数组复制一份而是“退化”成指向首元素的指针。因此函数内部用sizeof(arr)拿到的是指针大小不是数组长度。传参方式写法函数内能改外部数据吗典型陷阱值传递void f(int x)不能改了形参实参不变地址传递void f(int *p)能需要手动解引用指针可能为 NULL数组传参void f(int arr[])能sizeof 结果是 8 不是数组长度数组传参带长度void f(int arr[], int n)能长度信息必须额外传否则越界我平时写数组相关的函数几乎都是“数组名 长度”两个参数一起传而且函数内部绝不依赖 sizeof 去推数组长度因为那在传递之后已经不可靠了。1.3 return 和“未定义行为”的隐藏规则函数定义的返回值类型如果写了int那函数内部每条 return 路径都应该返回一个 int 值。这不是小问题。编写一个非 void 函数但代码里有一条路径没写 return编译器通常会警告但依然能编译产生可执行文件。这个函数运行时那条路径实际会返回什么答案是谁都不知道。它可能是上一个函数调用遗留的寄存器值也可能是垃圾数据。还有一种很容易被忽略的未定义行为函数实参的求值顺序不保证。比如int i 1; printf(%d %d\n, i, i);i和i的求值顺序在 C 标准里没有明确规定不同编译器、不同优化级别下结果可能不同。这类代码在任何正式项目里都应该直接避开不要拿“我电脑上跑出来是对的”当作理由。int func(void) { return; // 返回类型是 int却写 return; 编译器一定会给警告 }void 函数里倒是可以写return;用来提前结束但也不能在 void 函数里写return 3;那样编译器直接报错。2. 函数声明的工程级玩法从头文件到 static/extern2.1 为什么要把函数拆到头文件和源文件单个 main.c 文件做练习没问题一旦工程超过几千行函数就得按模块拆开。常见的做法是给每个模块建立一对文件math_utils.h和math_utils.c。头文件里只放#ifndef MATH_UTILS_H #define MATH_UTILS_H int add(int a, int b); int sub(int a, int b); #endif源文件里放实现#include math_utils.h int add(int a, int b) { return a b; } int sub(int a, int b) { return a - b; }main.c 里只需要#include math_utils.h就能调用add和sub。这样做的核心价值有两点第一编译单元之间解耦修改math_utils.c的实现细节时只要函数签名不变main.c 不需要重新理解第二别人看头文件就能知道模块对外提供了什么能力不需要翻完整份源码。2.2 头文件守卫防止重复包含的保命符把一个头文件 include 两次常见的后果是结构体和函数声明重复定义报错。头文件守卫的写法有新旧两种// 传统方式 #ifndef MATH_UTILS_H #define MATH_UTILS_H // 内容 #endif // 新写法很多现代编译器支持 #pragma once#pragma once写法更简洁但不是 C 标准规定的内容部分老编译器可能不认。为了兼容性我在课程作业和开源项目里都习惯用传统的#ifndef方案。这个习惯也救过我几次因为工程里可能 A.h 包含 B.hC.h 也包含 B.h而 A.h 又被 C.h 包含重复包含的链条一旦形成只有头文件守卫能拦住。2.3 static 和 extern函数也有“对外可见性”很多初学者只知道 static 能修饰局部变量其实 static 修饰函数时含义是“限制该函数只能在本源文件内使用”。我们写一个helper.c如果里面定义了static int calc(int x)就算 main.c 写了extern int calc(int);也无法链接成功。因为 calc 的内部链接属性决定了它不会参与链接器符号解析。extern 刚好相反它声明一个函数或变量在别处定义告诉编译器“你不要因为它没定义就报错链接的时候能找到”。头文件里的函数声明其实默认就是 extern 的不写也可以。我给一个经验性建议模块内部使用的辅助函数一律加 static缩小暴露面模块对外提供的接口在头文件里声明不加 static全局变量的使用要克制能不用就不用用了就明确加 extern 做显式声明别靠猜。3. 递归从“看懂的递归”到“能设计的递归”3.1 递归三要素与调用栈模型递归是函数调用自身的一种写法但它不是“自己调用自己”这么简单背后最关键的是调用栈模型。每调用一个函数系统就在栈上分配一块栈帧用来存放这个函数的局部变量、参数、返回地址。递归调用发生“自己调用自己”时同一份函数代码会被压入多层栈帧每一层的局部变量都是独立的互不干扰。设计递归时我建议盯住三个要素基线条件递归出口递归到什么时候停止递归条件问题规模如何缩小向基线条件逼近返回值与状态每层递归向上一层传递什么信息。举个例子计算n!long long factorial(int n) { if (n 1) return 1; return n * factorial(n - 1); }这里n 1是基线条件factorial(n - 1)把规模从 n 缩小到 n-1最后结果一层层乘回来。递归树的深度是 n如果 n 到 50 万调用栈就会被撑爆这也就是“栈溢出”的直接来源。3.2 实战一递归逆序字符串这个题目在 PTA、LeetCode 和各类 C 语言习题集里反复出现给定一个字符串原地逆序。用递归实现的核心思路是“交换首尾然后缩小范围继续处理内部”。#include stdio.h #include string.h void reverse_recursive(char s[], int left, int right) { if (left right) // 基线条件只剩一个字符或越界 return; char tmp s[left]; s[left] s[right]; s[right] tmp; reverse_recursive(s, left 1, right - 1); } int main(void) { char s[] hello; reverse_recursive(s, 0, (int)strlen(s) - 1); printf(%s\n, s); // 输出 olleh return 0; }注意这里字符串数组不能用char *s hello因为字符串字面量通常存放在只读区直接修改会触发段错误。用字符数组char s[] hello;才能安全修改。这个坑藏在题目表面之下很容易被忽略我当年就在这上面花过一晚上。3.3 实战二递归把整数转成字符串另一个经典题将一个整数 n 转换成字符串。比如输入 12345输出 12345。递归解法非常自然先处理 n 的高位再处理个位。因为“取末位”特别简单而“取高位”需要递归去处理整除后的结果。#include stdio.h void itoa_recursive(int n, char buf[], int *idx) { if (n 0) { buf[(*idx)] -; n -n; } if (n 10) itoa_recursive(n / 10, buf, idx); buf[(*idx)] 0 n % 10; } int main(void) { char buf[64] {0}; int idx 0; itoa_recursive(-12345, buf, idx); buf[idx] \0; printf(%s\n, buf); // 输出 -12345 return 0; }这里有两个细节值得展开。第一为什么用char buf[]而不是返回值因为 C 语言没法直接返回一个局部字符数组返回它的首地址指向的是栈上空间函数一结束就被回收了。所以一般都通过指针把结果写进外面准备好的缓冲区。第二负数的处理先写入负号再处理绝对值。不过n -n对于 int 最小值时可能溢出更安全的做法是把负数转换成 unsigned int 再处理这部分我在代码里没有进一步展开但在项目实战中必须考虑。3.4 实战三递归二路归并排序归并排序是“递归分治”的经典代表也是我特别建议手敲一遍的题目。它的思路很朴素把数组从中间分成两半分别递归排序再合并两个有序序列。#include stdio.h #include stdlib.h static void merge(int arr[], int left, int mid, int right, int tmp[]) { int i left, j mid 1, k 0; while (i mid j right) { if (arr[i] arr[j]) tmp[k] arr[i]; else tmp[k] arr[j]; } while (i mid) tmp[k] arr[i]; while (j right) tmp[k] arr[j]; for (i 0; i k; i) arr[left i] tmp[i]; } static void merge_sort_impl(int arr[], int left, int right, int tmp[]) { if (left right) return; int mid left (right - left) / 2; merge_sort_impl(arr, left, mid, tmp); merge_sort_impl(arr, mid 1, right, tmp); merge(arr, left, mid, right, tmp); } void merge_sort(int arr[], int n) { int *tmp (int *)malloc(sizeof(int) * n); if (tmp NULL) return; merge_sort_impl(arr, 0, n - 1, tmp); free(tmp); } int main(void) { int arr[] {5, 2, 4, 6, 1, 3}; int n (int)(sizeof(arr) / sizeof(arr[0])); merge_sort(arr, n); for (int i 0; i n; i) printf(%d , arr[i]); printf(\n); return 0; }归并排序的时间复杂度是 O(n log n)空间复杂度是 O(n)因为合并过程需要一个临时数组。它在数据规模大时非常稳定不像快速排序在最坏情况下可能退化到 O(n^2)。这里的递归深度是 log2(n)一个 100 万的数组递归深度也就 20 层左右完全不用担心爆栈。这也是我课堂上如果讲递归必定会把它和线性深度递归如阶乘做个对比的原因同样是“自己调用自己”递归深度完全不是一个量级。3.5 尾递归它不一定被优化别依赖尾递归是指递归调用发生在函数的最后一步函数的返回值直接就是这个递归调用的结果。int factorial_tail(int n, int acc) { if (n 1) return acc; return factorial_tail(n - 1, n * acc); }这个概念很容易让人以为“尾递归一定不会爆栈”。实际上C 标准并没有要求编译器做尾调用优化。GCC 在开启 -O2 优化时通常会帮你优化掉但如果你用的是默认编译选项递归深度该爆栈还是会爆栈。所以写递归的时候我的落脚点永远是“递归深度是否可控”而不是“这是不是尾递归”。4. 作用域深度解析变量到底活在哪儿4.1 作用域与生存期两个被混为一谈的概念很多人把作用域理解成“变量能用的范围”这没错但容易忽略另一个维度生存期也就是变量在内存里从创建到销毁的时间段。作用域回答“在哪能看见”生存期回答“什么时候还活着”。C 语言里作用域主要分几层作用域类型定义位置可见范围生存期块作用域花括号内部、for 循环内部从定义处到块结束块执行期间自动分配回收函数作用域函数内部整个函数体函数执行期间文件作用域函数外、所有花括号外定义处到文件末尾程序启动到结束函数原型作用域函数声明参数列表里原型结束即失效无实际存储静态局部变量函数内加了 static函数内部程序启动到结束我用一个代码片段说明作用域和生存期#include stdio.h int g_count 0; // 文件作用域生存期贯穿整个程序 void counter(void) { static int calls 0; // 静态局部变量作用域在 counter 内生存期却在整个程序 int local 1; // 自动局部变量作用域在 counter 内生存期也只在 counter 执行期间 calls; g_count; printf(calls%d, g_count%d, local%d\n, calls, g_count, local); } int main(void) { counter(); counter(); counter(); return 0; }运行结果里calls会依次变成 1、2、3。这说明虽然它的作用域只在counter函数里面但它的存储空间不是每次调用都重新分配的。static 关键字改变了生存期却没有改变作用域。4.2 static 的三副面孔static 应该是 C 语言里除了指针之外最容易被误解的关键字了。它总共有三种用法含义各不相同修饰函数内的局部变量把生存期延长到整个程序作用域不变。修饰文件里的全局变量把链接属性从外部链接变成内部链接只允许当前源文件访问。修饰函数和修饰全局变量一样限制函数只能在本源文件使用。万一记不住可以用一句话概括记忆static 的底层语义是“限制可见范围或者延长生存期”。到底限制哪个、延长哪个取决于修饰的是哪种对象。为什么模块内部函数要加 static想象你正在写一个排序库内部有一个swap辅助函数。如果不加 static链接器会把swap符号暴露给整个程序万一其他模块也定义了同名swap链接阶段可能直接冲突甚至产生诡异的运行时错误。加上 static 之后符号不会被导出到外部相当于把这个函数“私有化”了。我看过不少项目明明三个模块内部都有叫init的辅助函数因为都没加 static链接到后期就报重复定义。这种问题排查起来特别费时间而且往往不是语法错误是符号冲突。4.3 遮蔽问题变量名字冲突时谁说了算当内层作用域和外层作用域有同名变量时内层会“遮蔽”外层#include stdio.h int x 10; int main(void) { int x 20; { int x 30; printf(%d\n, x); // 输出 30 } printf(%d\n, x); // 输出 20 return 0; }遮蔽本身是合法语法但工程上带来的麻烦远大于便利。我常看到的问题是全局变量叫index函数参数也叫index结果在函数内部想访问全局变量时却只能拿到参数的值。C 语言没有提供类似“用命名空间解决冲突”的机制唯一的办法是编码习惯上做一个硬约束局部变量不要和外层作用域的变量重名全局变量尽量带统一前缀比如g_。遮蔽一旦发生代码可读性会迅速下降。我在 Code Review 时看到for (int i 0; ...)里面又嵌套一层for (int i ...)哪怕编译能过都会建议立刻改名。4.4 对照一下其他语言里的“作用域”热词榜里经常同时出现“bean 的作用域”“lambda 函数”“核函数”这类词它们和 C 语言作用域有有趣的对照。Java Spring 里的 bean 作用域概念本质上讨论的是对象实例的存活范围singleton 是全局一份prototype 是每次获取新建一个。C 语言里没有容器没有 bean但 static 局部变量和普通局部变量的对比跟 singleton 和 prototype 的区别非常相似。lambda 函数在 JavaScript/Python 里表示一个匿名函数块它自带“闭包”能力能捕获外层变量。C 语言标准之前没有 lambda但通过函数指针加全局变量或者结构体也能模拟出“把一个函数作为数据传来传去”的效果。回调函数就是这么来的你把一个函数指针传给某个 API让它在合适时机调用这个函数就可以在运行时才确定具体行为。核函数在并行计算或嵌入式领域经常出现。内核函数kernel function和普通 C 函数最大的区别是运行上下文不同普通函数运行在主机 CPU 栈上而内核函数运行在专用设备的执行单元上作用域和内存模型都会发生变化。理解了学习 C 语言的作用域再看这些衍生概念时你会更容易抓住“什么东西在哪里可见、在哪里存活”这条主线。5. 常见编译报错与排查实录5.1 “函数未声明”与“未定义引用”两种报错的区分这是新手最容易混淆的两类报错。区别非常简单“未声明”implicit declaration发生在编译阶段编译器没看到函数原型。“未定义引用”undefined reference发生在链接阶段编译器看到了声明但链接器找不到函数的定义。我在排查这类问题时会先看编译日志的最后阶段。如果报错信息里带undefined reference我第一个反应是检查这个函数是不是声明了但没写实现对应的 .c 文件有没有被加进编译命令函数定义是不是被 static 修饰成了一个内部函数外部文件根本调用不到5.2 类似“无法将 claude 识别为 cmdlet”的环境问题最近很多人搜“无法将 claude 识别为 cmdlet、函数、脚本文件或可运行程序的名称”这本质是 Windows 的 PowerShell 环境变量 PATH 里找不到对应命令行工具的路径。C 语言编译环境里一模一样的报错是“无法将 gcc 识别为 cmdlet ...”或者“gcc 不是内部或外部命令”。解决办法通常是两步确认 gcc 装在哪比如D:\mingw64\bin\gcc.exe把这个bin路径加进系统环境变量 PATH重新打开终端。我用 VSCode 配 C 语言环境时经常碰到 tasks.json 里配置好了编译命令但终端里敲 gcc 依然报错。原因就是 VSCode 继承的环境变量来自旧的终端会话重启 VSCode 或者新开终端即可解决。另外建议装了 MinGW-w64 之后先在终端执行gcc --version确认版本能输出再搞编辑器配置否则很容易分不清是环境问题还是编辑器问题。还有一个更隐蔽的点PowerShell 对安全策略有执行策略限制有时.ps1脚本跑不了会提示“禁止运行脚本”。这跟编译器本身无关可以在 PowerShell 里执行Get-ExecutionPolicy查看当前策略。不过为了安全和省心我在 Windows 上写 C 语言一般直接用 VSCode 的集成终端或者 Windows Terminal不折腾全局策略那些东西。5.3 用 gdb 观察递归调用栈递归程序一旦出问题最常见的是段错误。你看到的报错可能只有一行Segmentation fault (core dumped)。这时候我会把程序放进 gdb 里跑gcc -g -o test test.c gdb ./test run程序崩溃后在 gdb 里输入bt查看调用栈(gdb) bt #0 factorial (n0) at test.c:5 #1 0x... in factorial (n1) at test.c:7 #2 0x... in factorial (n2) at test.c:7 #3 0x... in main (n3) at test.c:12看到几十层甚至上万层的factorial栈帧基本上可以判定递归深度失控。这类问题的修复方向也明确要么检查基线条件是否真的能收敛要么把递归改成迭代要么用“分治类递归”如归并排序控制深度。如果不想用 gdb用printf打印每层递归的参数也可以。我当年学递归时全靠printf(enter n%d\n, n);这样的辅助输出一层一层看调用顺序。但注意递归层数过高时 printf 的输出量会非常大最好限制在调试阶段使用正式代码里别留。5.4 一个真实排错的完整过程我前阵子帮学弟调试一段代码背景是冒泡排序封装成函数后main 里排序结果还是原来的顺序。代码简化后长这样#include stdio.h void bubble_sort(int arr[], int n) { for (int i 0; i n - 1; i) { for (int j 0; j n - 1 - i; j) { if (arr[j] arr[j 1]) { int tmp arr[j]; arr[j] arr[j 1]; arr[j 1] tmp; } } } } int main(void) { int arr[] {5, 2, 4, 6, 1, 3}; int n (int)(sizeof(arr) / sizeof(arr[0])); bubble_sort(arr, n); for (int i 0; i n; i) printf(%d , arr[i]); printf(\n); return 0; }这段代码本身没有语法问题数组传参也传的是地址按理说 flush 到 main 里的数组会被排序。但学弟在他的版本里写成了这样int tmp; tmp arr[j]; arr[j] arr[j 1]; arr[j 1] tmp;打印调试后发现tmp的值始终不对。最终定位到他写的tmp是一个全局变量而他在另一个函数里也用了同名的tmp两个tmp互相污染。这种问题的根子就是全局变量的滥用和变量遮蔽。把tmp改成函数内部局部变量后一切正常。这一类问题给我的教训是函数内部能用的临时变量就老老实实写在函数内部。为了图方便把所有变量堆成全局变量后面排查的成本远超节省的那点输入量。6. 一些围绕函数设计的心得函数设计到最后其实拼的是“划分职责”和“命名”的能力。我现在的习惯是一个函数只做一件明确的事函数名尽量用动词加对象比如read_config、calculate_average、free_memory。如果函数超过二三十行我会停下来问自己这段逻辑能不能拆成更小的辅助函数。递归学习有一个很实用的心法先相信“子问题已经解决了”再写当前层的逻辑。写归并排序时“左半区间已经有序、右半区间已经有序”是一个假设你只需要关心合并逻辑写字符串逆序时“剩下的子串已经逆序”也是一个假设你只需要处理首尾两个字符。很多人写递归卡住是因为老想去逐层跟踪变量跟踪三层就晕了。作用域这块我再给一个自我检查清单这个变量是不是真的需要全局不全局行不行这个全局变量是否只有当前文件使用如果是加上 static 变成内部链接。函数里有没有和外层重名的变量有就改名。静态局部变量的值是否会破坏函数的可重入性如果在并发或递归场景下调用这个函数静态变量的状态可能会被多个调用方共用从而产生隐患。递归函数里尤其不要轻易用静态局部变量来存中间状态。其实写完这一篇之后你会发现递归和作用域这两块更像是“思维方式”而不是“语法知识”。递归是分治思想的直接体现作用域是程序状态管理的基石。把这两个点吃透之后再去学函数指针、回调函数、模块化设计会顺畅很多。后面我计划单独写一篇关于函数指针和回调的笔记把“函数作为数据传递”这条路补上到时候再一起聊。