第9章 函数（下）：作用域与生命周期、递归函数、static与extern关键字、内联函数

函数这东西，写C代码的人天天都在用。但说实话，很多人写了几年，对函数背后的那些“潜规则”还是一知半解。比如：这个变量到底什么时候被创建？什么时候被销毁？为什么这个函数在另一个文件里调用不了？

这一章，我们就来把这些“坑”填平。我会结合自己踩过的雷，把作用域、生命周期、递归、static、extern、内联这些概念一次性讲透。

9.1 作用域与生命周期——变量到底“活”在哪？

先问个问题：你在函数里定义了一个变量，出了这个函数还能用吗？答案显然是不能。但为什么不能？这就涉及到两个核心概念：作用域和生命周期。

作用域，说白了就是变量能被“看见”的范围。
生命周期，就是变量从出生到死亡的时间段。

我刚开始学C时，经常把这两个搞混。后来遇到一个bug，调试了一下午才发现：一个局部变量在函数返回后，它的内存已经被回收了，但我还在另一个地方用指针去访问它。嗯，典型的“悬空指针”问题。

来看个例子：

#include <stdio.h>

int global_var = 100;  // 全局变量，作用域：整个文件，生命周期：程序运行期间

void func() {
    int local_var = 10;  // 局部变量，作用域：func函数内，生命周期：函数调用期间
    static int static_var = 0;  // 静态局部变量，作用域：func函数内，生命周期：程序运行期间
    static_var++;
    printf("local_var = %d, static_var = %d\n", local_var, static_var);
}

int main() {
    func();
    func();
    func();
    // printf("%d", local_var);  // 错误！local_var在这里不可见
    return 0;
}

运行结果：

local_var = 10, static_var = 1
local_var = 10, static_var = 2
local_var = 10, static_var = 3

看到了吗？local_var每次调用都重新创建，所以一直是10。而static_var只初始化一次，每次调用都会累加。这就是生命周期不同导致的差异。

9.2 static关键字——不只是“静态”那么简单

static这个关键字，我见过太多人用错了。它其实有两个完全不同的用途，取决于你把它用在什么地方。

9.2.1 static修饰局部变量

就像上面那个例子，static修饰局部变量时，它会让这个变量的生命周期变成全局的，但作用域仍然是局部的。说白了就是：函数结束了，它还在；但除了这个函数，谁也碰不到它。

我在项目中常用它来做“函数调用计数器”：

int get_next_id() {
    static int id = 0;
    return id++;
}

每次调用，id都会递增。而且不用担心别的函数不小心改了这个值。

9.2.2 static修饰全局变量或函数

当static用在全局变量或函数前面时，它的意思是：这个变量/函数只在本文件内可见。

举个例子：

// file1.c
static int secret = 42;  // 只有file1.c能看到
void helper() { ... }     // 默认全局可见

// file2.c
extern int secret;  // 错误！找不到secret，因为它是static的

我曾经在一个多人协作的项目里，就是因为没加static，导致两个文件里的全局变量重名，编译没报错，但运行结果完全不对。从那以后，我养成了一个习惯：只要不是必须暴露给外部的全局变量或函数，一律加上static。

9.3 extern关键字——让变量“跨文件”工作

有static限制可见性，就有extern扩展可见性。extern的作用很简单：告诉编译器，这个变量或函数在别的文件里定义了，你在这里先用着。

用法示例：

// global.h
extern int shared_counter;  // 声明，不是定义

// file1.c
#include "global.h"
int shared_counter = 0;  // 定义

void increment() {
    shared_counter++;
}

// file2.c
#include "global.h"
#include <stdio.h>

void print_counter() {
    printf("Counter = %d\n", shared_counter);  // 使用file1.c中定义的变量
}

这里有个容易犯的错误：声明和定义的区别。

• int shared_counter; —— 这是定义，会分配内存
• extern int shared_counter; —— 这是声明，不会分配内存，只是告诉编译器“这个变量存在”

如果你在多个文件里都写了int shared_counter;，链接时会报“重复定义”的错误。正确的做法是：在一个文件里定义，在其他文件里用extern声明。

9.4 递归函数——函数调用自己，真的可以吗？

递归，就是函数调用自身。听起来有点绕，但用对了地方，代码会非常简洁。

最经典的例子：计算阶乘。

int factorial(int n) {
    if (n <= 1) {
        return 1;  // 递归终止条件
    }
    return n * factorial(n - 1);  // 递归调用
}

递归的核心就两点：

1. 递归终止条件——没有这个，函数会无限调用下去，最终栈溢出
2. 递归关系——把大问题分解成小问题

我记得有一次，一个同事写了一个递归函数，没有加终止条件。程序跑起来后，内存占用一路飙升，最后系统直接崩溃了。嗯，从那以后，我每次写递归都会先检查终止条件。

再来看一个更实用的例子：遍历二叉树。

typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

void inorder_traversal(Node* root) {
    if (root == NULL) {
        return;  // 终止条件
    }
    inorder_traversal(root->left);   // 遍历左子树
    printf("%d ", root->data);       // 访问根节点
    inorder_traversal(root->right);  // 遍历右子树
}

递归的缺点也很明显：每次调用都会消耗栈空间。如果递归深度太大，比如几万层，栈就会溢出。在嵌入式系统中，栈空间通常很小，所以递归要慎用。

9.5 内联函数——用空间换时间

函数调用是有开销的：参数压栈、跳转、返回、清理栈……如果一个函数很小，比如就两三行代码，调用它的开销可能比函数本身执行的时间还长。

inline关键字就是用来解决这个问题的。它建议编译器：把这个函数的代码直接“粘贴”到调用处，省去函数调用的开销。

inline int max(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    int x = max(10, 20);  // 编译器可能会直接替换成: int x = (10 > 20) ? 10 : 20;
    return 0;
}

注意，inline只是一个“建议”，不是强制命令。编译器有权忽略它。比如函数体太大、或者有递归调用，编译器通常就不会内联。

我在项目中用过一次内联函数，是在一个循环里频繁调用一个简单的校验函数。加上inline后，性能提升了大约15%。但说实话，大部分情况下，现代编译器的优化能力已经很强了，你写不写inline差别不大。

知识体系总览

下面这张图，把本章的核心知识点串了起来。你可以把它当作一个“思维导图”来用。

这张图把本章的五个核心知识点都串起来了。你可以看到，作用域与生命周期是基础，static和extern是控制可见性的两个“开关”，递归是一种特殊的函数调用方式，而内联函数则是一种优化手段。

学完这一章，你应该能回答这些问题：

• 一个变量在函数结束后还能不能存在？
• 怎么让一个变量只在本文件内可见？
• 怎么在另一个文件里使用这个文件的全局变量？
• 递归函数怎么写才不会栈溢出？
• 什么时候该用内联函数？

这些知识点，在实际项目中几乎天天都会遇到。尤其是static和extern，我几乎在每个嵌入式项目里都会用到。记住：写代码不只是让编译器通过，更要让代码清晰、可维护、不出bug。

---

公众号:蓝海资料掘金营，微信deep3321