C语言教程

Appearance

存储类 ​

在C语言中，存储类决定了变量的存储位置、作用域和生命周期。不同的存储类会影响变量的行为和使用方式。在本章节中，我们将学习C语言中的各种存储类及其特点。

1. 什么是存储类？ ​

存储类是C语言中用于控制变量存储方式的关键字。它们决定了：

  1. 存储位置：变量存储在内存的哪个区域（栈、堆、静态存储区等）
  2. 作用域：变量可以在程序的哪些部分被访问
  3. 生命周期：变量从创建到销毁的时间范围
  4. 初始化：变量的默认初始化值

2. C语言中的存储类 ​

C语言提供了以下几种存储类：

  1. auto：自动存储类
  2. register：寄存器存储类
  3. static：静态存储类
  4. extern：外部存储类

3. auto存储类 ​

auto是C语言中默认的存储类，用于声明局部变量。当你定义一个局部变量时，如果没有指定存储类，它默认就是auto类型。

3.1 特点 ​

  • 存储位置：栈内存
  • 作用域：定义它的代码块（如函数或复合语句）内部
  • 生命周期：从进入代码块开始，到离开代码块结束
  • 初始化：未初始化的auto变量包含随机值

3.2 语法 ​

c
auto 数据类型 变量名;

由于auto是默认的存储类，通常可以省略不写：

c
int a;  // 等同于 auto int a;
auto int b;  // 显式使用auto

3.3 示例 ​

c
#include <stdio.h>

void function() {
    auto int x = 10;  // 自动变量
    printf("x = %d\n", x);
}

int main() {
    function();
    // printf("x = %d\n", x);  // 错误：x超出作用域
    return 0;
}

4. register存储类 ​

register存储类用于声明寄存器变量，建议编译器将变量存储在CPU寄存器中，以提高访问速度。

4.1 特点 ​

  • 存储位置：CPU寄存器（如果可能）
  • 作用域：定义它的代码块内部
  • 生命周期：从进入代码块开始，到离开代码块结束
  • 初始化：未初始化的register变量包含随机值
  • 限制：不能取register变量的地址（&运算符）

4.2 语法 ​

c
register 数据类型 变量名;

4.3 示例 ​

c
#include <stdio.h>

int main() {
    register int i;  // 寄存器变量
    int sum = 0;
    
    // 计算1到100的和
    for (i = 1; i <= 100; i++) {
        sum += i;
    }
    
    printf("Sum: %d\n", sum);
    // printf("&i: %p\n", &i);  // 错误：不能取寄存器变量的地址
    
    return 0;
}

4.4 注意事项 ​

  • register只是一个建议，编译器可能会忽略这个建议
  • 只有频繁使用的变量（如循环计数器）才适合使用register
  • 寄存器数量有限，不能定义太多register变量

5. static存储类 ​

static存储类用于声明静态变量，可以改变变量的作用域和生命周期。

5.1 静态局部变量 ​

当static用于函数内部的局部变量时：

  • 存储位置：静态存储区
  • 作用域：定义它的函数内部
  • 生命周期：从程序开始执行到程序结束
  • 初始化：未初始化的静态局部变量默认初始化为0

5.2 静态全局变量 ​

当static用于函数外部的全局变量时：

  • 存储位置：静态存储区
  • 作用域：定义它的文件内部
  • 生命周期：从程序开始执行到程序结束
  • 初始化：未初始化的静态全局变量默认初始化为0

5.3 静态函数 ​

当static用于函数时：

  • 作用域：定义它的文件内部
  • 其他特性：与普通函数相同

5.4 语法 ​

c
// 静态局部变量
void function() {
    static 数据类型 变量名;
}

// 静态全局变量
static 数据类型 变量名;

// 静态函数
static 返回类型 函数名(参数列表) {
    // 函数体
}

5.5 示例 ​

5.5.1 静态局部变量 ​

c
#include <stdio.h>

void count() {
    static int counter = 0;  // 静态局部变量
    counter++;
    printf("Counter: %d\n", counter);
}

int main() {
    count();  // 输出 Counter: 1
    count();  // 输出 Counter: 2
    count();  // 输出 Counter: 3
    return 0;
}

在这个例子中，counter是一个静态局部变量，它的生命周期是整个程序的运行时间，所以每次调用count()函数时，它的值会保留。

5.5.2 静态全局变量 ​

c
// file1.c
static int global_var = 100;  // 静态全局变量

void print_global() {
    printf("global_var: %d\n", global_var);
}

// file2.c
// extern int global_var;  // 错误：无法访问file1.c中的静态全局变量

在这个例子中，global_var是一个静态全局变量，它只能在file1.c文件中被访问，无法在其他文件中使用。

6. extern存储类 ​

extern存储类用于声明外部变量，表示变量在其他文件中定义，需要在当前文件中使用。

6.1 特点 ​

  • 存储位置：静态存储区
  • 作用域：整个程序
  • 生命周期：从程序开始执行到程序结束
  • 初始化：未初始化的外部变量默认初始化为0

6.2 语法 ​

c
extern 数据类型 变量名;

6.3 示例 ​

6.3.1 外部变量的使用 ​

c
// file1.c
int global_var = 100;  // 定义全局变量

// file2.c
extern int global_var;  // 声明外部变量

int main() {
    printf("global_var: %d\n", global_var);  // 输出 global_var: 100
    return 0;
}

在这个例子中，global_var在file1.c中定义，在file2.c中使用extern声明后就可以访问了。

6.3.2 外部函数的声明 ​

c
// file1.c
void print_message() {
    printf("Hello from file1.c\n");
}

// file2.c
extern void print_message();  // 声明外部函数

int main() {
    print_message();  // 调用在file1.c中定义的函数
    return 0;
}

7. 存储类的比较 ​

存储类存储位置作用域生命周期默认初始化值
auto栈内存代码块内代码块执行期间随机值
register寄存器（如果可能）代码块内代码块执行期间随机值
static（局部）静态存储区函数内整个程序运行期间0
static（全局）静态存储区文件内整个程序运行期间0
extern静态存储区整个程序整个程序运行期间0

8. 存储类的使用场景 ​

8.1 auto存储类 ​

  • 适用场景：大多数局部变量
  • 优点：自动管理内存，使用方便
  • 缺点：生命周期短，离开作用域后值丢失

8.2 register存储类 ​

  • 适用场景：频繁使用的变量（如循环计数器）
  • 优点：访问速度快
  • 缺点：数量有限，不能取地址

8.3 static存储类 ​

  • 静态局部变量：需要在函数调用之间保留值的变量
  • 静态全局变量：只在当前文件中使用的全局变量
  • 静态函数：只在当前文件中使用的函数

8.4 extern存储类 ​

  • 适用场景：需要在多个文件中共享的变量或函数
  • 优点：实现文件间的数据共享
  • 缺点：可能导致命名冲突

9. 示例：综合运用 ​

让我们看一个综合运用各种存储类的例子：

c
#include <stdio.h>

// 全局变量（默认extern）
int global_var = 100;

// 静态全局变量
static int static_global_var = 200;

// 静态函数
static void static_function() {
    printf("Static function called\n");
}

// 外部函数声明
extern void external_function();

void test_auto_register() {
    // auto变量（默认）
    int auto_var = 10;
    
    // register变量
    register int register_var = 20;
    
    printf("auto_var: %d\n", auto_var);
    printf("register_var: %d\n", register_var);
}

void test_static_local() {
    // 静态局部变量
    static int static_local_var = 0;
    static_local_var++;
    printf("static_local_var: %d\n", static_local_var);
}

int main() {
    printf("global_var: %d\n", global_var);
    printf("static_global_var: %d\n", static_global_var);
    
    test_auto_register();
    
    test_static_local();  // 输出 1
    test_static_local();  // 输出 2
    test_static_local();  // 输出 3
    
    static_function();
    
    // external_function();  // 调用外部函数
    
    return 0;
}

10. 注意事项 ​

  1. 存储类的选择：根据变量的使用场景选择合适的存储类
  2. 静态变量的初始化：静态变量只初始化一次，在程序启动时
  3. 外部变量的声明：使用extern声明外部变量时，不要赋值
  4. 寄存器变量的限制：不要定义太多寄存器变量，以免超出CPU寄存器数量
  5. 命名冲突：避免使用相同名称的全局变量，以免造成冲突

11. 示例：静态变量的应用 ​

静态变量常用于需要在函数调用之间保持状态的场景，例如计数器、缓存等：

c
#include <stdio.h>

// 生成唯一ID的函数
int generate_id() {
    static int id = 0;  // 静态局部变量，每次调用后值会保留
    return ++id;
}

int main() {
    printf("ID 1: %d\n", generate_id());  // 输出 1
    printf("ID 2: %d\n", generate_id());  // 输出 2
    printf("ID 3: %d\n", generate_id());  // 输出 3
    return 0;
}

小结 ​

C语言中的存储类决定了变量的存储位置、作用域和生命周期：

  1. auto：默认存储类，用于局部变量，存储在栈中
  2. register：建议存储在寄存器中，用于频繁使用的变量
  3. static：静态存储类，用于需要长期保存值的变量或限制作用域
  4. extern：外部存储类，用于声明在其他文件中定义的变量

选择合适的存储类可以：

  • 提高程序的执行效率
  • 减少内存的使用
  • 避免命名冲突
  • 使代码结构更加清晰

在实际编程中，应根据变量的具体使用场景选择合适的存储类。

Copyright © 2025-2026 京公网安备 11010102000001号 京ICP备2024078128号-1