C语言中extern关键字的作用和链接机制是什么？

C语言中extern关键字的作用和链接机制是什么？

extern 关键字基本概念：

1. 声明外部变量

   c
   // file1.c
   int global_var = 100;
   
   // file2.c
   extern int global_var;  // 声明，不分配内存
   
   void function() {
       global_var = 200;  // 访问 file1.c 中的变量
   }

2. 声明外部函数

   c
   // file1.c
   int add(int a, int b) {
       return a + b;
   }
   
   // file2.c
   extern int add(int a, int b);  // 可省略 extern
   
   void use_add() {
       int result = add(3, 5);
   }

链接机制：

1. 内部链接 vs 外部链接

   c
   // 内部链接（static）
   static int internal_var = 10;
   static void internal_func() {}
   
   // 外部链接（默认）
   int external_var = 20;
   void external_func() {}
   
   // 显式外部链接
   extern int explicit_var = 30;
   extern void explicit_func() {}

2. 跨文件共享

   c
   // config.h
   extern int MAX_CONNECTIONS;
   extern const char* LOG_FILE;
   
   // config.c
   int MAX_CONNECTIONS = 100;
   const char* LOG_FILE = "app.log";
   
   // main.c
   #include "config.h"
   
   int main() {
       printf("Max connections: %d\n", MAX_CONNECTIONS);
   }

使用场景：

1. 头文件声明

   c
   // mylib.h
   #ifndef MYLIB_H
   #define MYLIB_H
   
   extern int library_version;
   extern void library_init();
   extern void library_cleanup();
   
   #endif

2. 避免重复定义

   c
   // common.h
   extern int shared_counter;
   
   // file1.c
   #include "common.h"
   int shared_counter = 0;  // 定义
   
   // file2.c
   #include "common.h"
   // 只声明，不定义

3. 条件编译

   c
   // platform.h
   #ifdef _WIN32
       extern void windows_specific();
   #elif defined(__linux__)
       extern void linux_specific();
   #endif

注意事项：

1. 声明 vs 定义

   c
   // 声明（不分配内存）
   extern int var1;
   
   // 定义（分配内存）
   int var1 = 10;
   extern int var2 = 20;  // 也是定义

2. const 变量的 extern

   c
   // 默认情况下 const 变量是内部链接
   const int CONSTANT = 100;
   
   // 需要显式声明为外部链接
   extern const int EXTERN_CONSTANT = 200;

3. 初始化

   c
   // 正确
   extern int var;  // 声明
   int var = 10;   // 定义
   
   // 错误
   extern int var = 10;  // 虽然合法，但不推荐

高级应用：

1. 动态链接库

   c
   // mylib.c
   __declspec(dllexport) int lib_function(int x) {
       return x * 2;
   }
   
   // main.c
   __declspec(dllimport) int lib_function(int x);

2. 内联函数

   c
   // header.h
   static inline int max(int a, int b) {
       return a > b ? a : b;
   }

3. 宏与 extern 结合

   c
   // api.h
   #ifdef API_EXPORTS
       #define API __declspec(dllexport)
   #else
       #define API __declspec(dllimport)
   #endif
   
   API void api_function();

最佳实践：

1. 头文件组织

   c
   // module.h
   #ifndef MODULE_H
   #define MODULE_H
   
   #ifdef __cplusplus
   extern "C" {
   #endif
   
   extern int module_init();
   extern void module_cleanup();
   
   #ifdef __cplusplus
   }
   #endif
   
   #endif

2. 避免全局变量

   c
   // 不推荐
   extern int global_state;
   
   // 推荐：使用访问函数
   int get_state();
   void set_state(int value);

3. 命名空间模拟

   c
   // network.h
   extern int network_init();
   extern void network_send(const char* data);
   
   // file.h
   extern int file_open(const char* path);
   extern void file_write(int fd, const char* data);

常见错误：

1. 重复定义

   c
   // file1.c
   int shared_var = 10;
   
   // file2.c
   int shared_var = 20;  // 链接错误：重复定义

2. 未定义引用

   c
   // file1.c
   extern int undefined_var;
   
   void function() {
       int x = undefined_var;  // 链接错误：未定义引用
   }

3. 类型不匹配

   c
   // file1.c
   int value = 10;
   
   // file2.c
   extern double value;  // 链接错误：类型不匹配