extern与static在C语言中作用有何区别？

核心概念：作用域 和 链接属性

在深入 extern 和 static 之前,我们必须先理解两个基本概念：

1. 作用域：指一个标识符（变量名、函数名）在代码的哪些区域内是可见的、可以被访问的。

   • 块作用域：由 包围的区域，比如函数体、循环体、if 语句块，在块内定义的变量,离开该块后就会被销毁。
   • 文件作用域：在所有函数之外定义的变量，其作用域从定义点开始,一直持续到该文件末尾。

2. 链接属性：指一个标识符在不同的翻译单元（可以简单理解为 .c 文件）之间是否可见。

   • 外部链接：该标识符可以被其他文件访问，一个全局变量或函数,默认具有外部链接。
   • 内部链接：该标识符只能在其所在的文件内访问，一个被 static 修饰的全局变量或函数,具有内部链接。
   • 无链接：该标识符只能在它的作用域（通常是块作用域）内访问，一个局部变量,默认无链接。

extern 和 static 的主要作用就是修改一个标识符的链接属性。

extern 关键字：声明外部链接

extern 的核心作用是“声明”一个变量或函数，告诉编译器：“这个东西（变量或函数）定义在别的地方，你先别给我分配内存，链接阶段会去找到它的定义。”

用于变量

场景：在多文件的项目中，多个 .c 文件需要共享同一个全局变量。

问题：如果在一个 .c 文件中定义全局变量，在另一个 .c 文件中直接使用，编译器会报错“未声明的标识符”,因为它不知道这个变量来自哪里。

解决方案：使用 extern。

工作方式：

• 定义：在一个文件（global.c）中，直接定义全局变量，这会分配内存。

  // global.c
  int counter = 0; // 这是定义，会分配内存

• 声明：在其他需要使用这个变量的文件（main.c）中，使用 extern 进行声明，这不分配内存，只是告诉编译器 counter 是一个外部定义的 int 类型变量。

  // main.c
  #include <stdio.h>
  extern int counter; // 这是声明，告诉编译器 counter 在别处定义
  void increment() {
      counter++;
  }
  int main() {
      printf("Counter: %d\n", counter); // 输出 0
      increment();
      printf("Counter: %d\n", counter); // 输出 1
      return 0;
  }

• extern int counter;：是一个声明，它告诉编译器 counter 存在，但它的定义在别处,它不分配内存。
• int counter = 0;：是一个定义，它为 counter 分配内存,并初始化。
• 在一个程序中，一个全局变量只能被定义一次，但可以被多次声明（用 extern）。
• extern 通常用于函数和具有文件作用域（全局）的变量。

用于函数

对于函数，extern 的行为是默认的，当你在一个文件中声明一个函数时（int add(int a, int b);），编译器默认会去其他文件中寻找它的定义，这个行为就等同于 extern。

下面的两种写法是等价的：

// file1.c
int add(int a, int b); // 默认是 extern int add(int a, int b);
// file2.c
int add(int a, int b) {
    return a + b;
}

显式地使用 extern 通常是为了代码的清晰性,强调这个函数是在外部定义的。

static 关键字：限制链接域

static 的作用与 extern 相反，它用于限制一个标识符的可见范围，使其内部链接或静态存储。

static 的行为取决于它所修饰的对象是变量还是函数。

用于全局变量和函数（修改链接属性）

当 static 用于文件作用域（全局）的变量或函数时，它将外部链接改为内部链接。

场景：你想创建一个全局变量或函数，但它只能在当前 .c 文件内使用，不希望被其他文件访问，这可以避免命名冲突,并封装实现细节。

示例：

// utils.c
#include <stdio.h>
// 这个函数只能在 utils.c 文件内被调用
static void helper_log(const char* message) {
    printf("[LOG] %s\n", message);
}
// 这个全局变量也只在 utils.c 内可见
static int debug_level = 1;
void public_function() {
    if (debug_level) {
        helper_log("public_function called");
    }
}

// main.c
#include <stdio.h>
// 下面这行会编译错误！因为 helper_log 是 static 的，内部链接，main.c 看不见
// void helper_log(const char* message);
// 下面这行也会编译错误！因为 debug_level 是 static 的
// extern int debug_level;
void public_function(); // 这个可以，因为它没有 static，具有外部链接
int main() {
    public_function(); // 可以调用，因为它不是 static
    // helper_log("hello"); // 错误！
    return 0;
}

• static 修饰全局变量/函数 -> 内部链接，作用域限制在定义它的文件内，这是实现封装和模块化的重要手段。

用于局部变量（修改存储期）

当 static 用于块作用域（局部）的变量时，它不改变链接属性（局部变量本就无链接），但它会改变变量的存储期。

• 普通局部变量：存储在栈上，函数被调用时创建，函数返回时销毁（自动生命周期）。
• static 局部变量：存储在静态/全局数据区，程序开始时创建，程序结束时销毁（静态生命周期），它的值会在函数调用之间保持不变。

场景：需要一个变量，它的作用域仅限于函数内部,但生命周期需要和整个程序一样长。

示例：

#include <stdio.h>
void count_calls() {
    // 普通局部变量，每次调用都会重新初始化为 0
    int local_counter = 0;
    local_counter++;
    printf("Local call count: %d\n", local_counter);
    // static 局部变量，只在第一次调用时初始化为 0，之后保持上一次的值
    static int static_counter = 0;
    static_counter++;
    printf("Static call count: %d\n", static_counter);
}
int main() {
    count_calls(); // Local: 1, Static: 1
    count_calls(); // Local: 1, Static: 2
    count_calls(); // Local: 1, Static: 3
    return 0;
}

• static 修饰局部变量 -> 静态存储期，变量在程序的整个生命周期中都存在，值在函数调用之间保留,它只初始化一次。

static 和 extern 的对比总结

经典面试题

问题：以下代码的输出是什么？

#include <stdio.h>
void test() {
    static int i = 0; // 1. static 局部变量
    int j = 0;       // 2. 普通局部变量
    i++;
    j++;
    printf("i = %d, j = %d\n", i, j);
}
int main() {
    test();
    test();
    return 0;
}

输出：

i = 1, j = 1
i = 2, j = 1

解释：

1. static int i = 0;：i 是一个静态局部变量，它只在 main 函数开始时初始化一次，值为 0。test 函数每次被调用时，i 的值都会保留并递增。
2. int j = 0;：j 是一个普通局部变量，它在每次 test 函数被调用时被创建，并初始化为 0，函数执行完毕后，j 被销毁，所以每次调用，j 的值都是 1。

希望这个详细的解释能帮助你彻底理解 extern 和 static 的区别和用法！