C 语言 static 关键字详解

嘻嘻爱编码

于 2024-02-26 07:00:00 发布

阅读量2.2k

点赞数 65

文章标签：算法 c语言开发语言 c++ java

本文链接：https://blog.csdn.net/u012730525/article/details/136288079

版权

C 语言 static 关键字详解

在 C 语言中，static 是一个非常有用的关键字，它可以用来修饰变量和函数，从而改变它们的作用域、存储方式和初始化方式。本文将介绍 static 关键字的三种常见用法，以及它们的优缺点和注意事项。

用于局部变量的修饰符

当 static 用于修饰局部变量时，通常是在某个函数体内，只能在该函数内被访问。这样定义的变量通常被称为局部静态变量，它的特点有以下几点：

局部静态变量在编译时就会在静态数据区分配空间，并且只会被初始化一次，如果没有显式初始化，那么默认初始化为 0。
局部静态变量的生命周期与程序的运行期相同，即使函数调用结束，它的值也不会被销毁，而是保留到下一次函数调用。
局部静态变量可以实现函数内部的状态保持，即记住上一次函数调用的结果，这在一些特殊的应用场景中很有用。

下面是一个使用局部静态变量的例子，它实现了一个计数器的功能，每次调用函数时，计数器的值会增加 1，并打印出来。

#include <stdio.h>

void counter(void) {
    static int count = 0; // 局部静态变量，只初始化一次
    count++; // 每次调用函数，计数器加一
    printf("The count is %d\n", count); // 打印计数器的值
}

int main(void) {
    for (int i = 0; i < 5; i++) {
        counter(); // 调用函数五次
    }
    return 0;
}

程序的运行结果如下：

The count is 1
The count is 2
The count is 3
The count is 4
The count is 5

可以看到，局部静态变量 count 在每次函数调用时都保持了上一次的值，并且不会被重置为 0。

使用局部静态变量的优点是可以隐藏变量，避免与其他函数的局部变量冲突，也可以减少参数的传递，简化函数的设计。但是也要注意以下几点：

局部静态变量会占用静态数据区的空间，如果过多使用，可能会影响程序的性能和内存效率。
局部静态变量会增加函数的复杂度和不可预测性，因为它的值不仅取决于当前的输入，还取决于之前的调用历史，这可能会导致一些难以发现的错误。
局部静态变量不是线程安全的，如果多个线程同时访问同一个函数，可能会造成数据的混乱和竞争，因此需要加锁或者使用线程局部存储（thread local storage）来保护。

用于全局变量的修饰符

当 static 用于修饰全局变量时，通常是在函数体外部，可以在整个文件内被访问。这样定义的变量通常被称为静态全局变量，它的特点有以下几点：

静态全局变量在编译时就会在静态数据区分配空间，并且只会被初始化一次，如果没有显式初始化，那么默认初始化为 0。
静态全局变量的生命周期与程序的运行期相同，不会因为函数的调用而改变。
静态全局变量的作用域仅限于当前文件，其他文件不能直接访问，也不能使用 extern 关键字来声明。

下面是一个使用静态全局变量的例子，它定义了两个文件，一个是 file1.c，另一个是 file2.c。在 file1.c 中，定义了一个静态全局变量 a 和一个普通全局变量 b，并在 main 函数中打印它们的值。在 file2.c 中，定义了一个与 file1.c 中同名的静态全局变量 a，并在一个函数中打印它的值，同时尝试使用 extern 关键字来引用 file1.c 中的变量。

// file1.c
#include <stdio.h>

static int a = 10; // 静态全局变量，只能在本文件内访问
int b = 20; // 普通全局变量，可以在其他文件内访问

int main(void) {
    printf("In file1.c, a = %d, b = %d\n", a, b); // 打印本文件内的变量
    print(); // 调用 file2.c 中的函数
    return 0;
}

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

static int a = 100; // 静态全局变量，与 file1.c 中的同名变量不冲突
extern int b; // 使用 extern 关键字来引用 file1.c 中的变量

void print(void) {
    printf("In file2.c, a = %d, b = %d\n", a, b); // 打印本文件内的变量和 file1.c 中的变量
}

程序的运行结果如下：

In file1.c, a = 10, b = 20
In file2.c, a = 100, b = 20

可以看到，静态全局变量 a 在两个文件中都有定义，但是互不影响，各自保持自己的值。而普通全局变量 b 可以在 file2.c 中通过 extern 关键字来引用，打印出 file1.c 中的值。

使用静态全局变量的优点是可以隐藏变量，避免与其他文件的全局变量冲突，也可以防止变量被误用或修改。但是也要注意以下几点：

静态全局变量会占用静态数据区的空间，如果过多使用，可能会影响程序的性能和内存效率。
静态全局变量会增加程序的耦合度，因为它的值可能会被多个函数共享和修改，这可能会导致一些难以发现的错误。
静态全局变量不是线程安全的，如果多个线程同时访问同一个变量，可能会造成数据的混乱和竞争，因此需要加锁或者使用线程局部存储（thread local storage）来保护。

用于函数的修饰符

当 static 用于修饰函数时，通常是在函数的返回类型前，表示该函数只能在当前文件内被调用。这样定义的函数通常被称为静态函数，它的特点有以下几点：

静态函数在编译时就会被分配到代码区，并且只能被当前文件内的其他函数调用，不会被其他文件内的函数调用。
静态函数的作用域仅限于当前文件，其他文件不能直接访问，也不能使用 extern 关键字来声明。
静态函数可以避免与其他文件中的同名函数冲突，也可以防止函数被误用或修改。

下面是一个使用静态函数的例子，它定义了两个文件，一个是 file1.c，另一个是 file2.c。在 file1.c 中，定义了一个静态函数 add 和一个普通函数 sub，并在 main 函数中调用它们。在 file2.c 中，定义了一个与 file1.c 中同名的静态函数 add，并在一个函数中调用它，同时尝试使用 extern 关键字来引用 file1.c 中的函数。

// file1.c
#include <stdio.h>

static int add(int a, int b) { // 静态函数，只能在本文件内调用
    return a + b;
}

int sub(int a, int b) { // 普通函数，可以在其他文件内调用
    return a - b;
}

int main(void) {
    printf("In file1.c, add(10, 20) = %d, sub(10, 20) = %d\n", add(10, 20), sub(10, 20)); // 调用本文件内的函数
    print(); // 调用 file2.c 中的函数
    return 0;
}

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

static int add(int a, int b) { // 静态函数，与 file1.c 中的同名函数不冲突
    return a * b;
}

extern int sub(int a, int b); // 使用 extern 关键字来引用 file1.c 中的函数

void print(void) {
    printf("In file2.c, add(10, 20) = %d, sub(10, 20) = %d\n", add(10, 20), sub(10, 20)); // 调用本文件内的函数和 file1.c 中的函数
}

程序的运行结果如下：

In file1.c, add(10, 20) = 30, sub(10, 20) = -10
In file2.c, add(10, 20) = 200, sub(10, 20) = -10

可以看到，静态函数 add 在两个文件中都有定义，但是互不影响，各自执行自己的逻辑。而普通函数 sub 可以在 file2.c 中通过 extern 关键字来引用，执行 file1.c 中的逻辑。

使用静态函数的优点是可以隐藏函数，避免与其他文件的同名函数冲突，也可以防止函数被误用或修改。但是也要注意以下几点：

静态函数会占用代码区的空间，如果过多使用，可能会影响程序的性能和内存效率。
静态函数会增加程序的耦合度，因为它的调用只能在当前文件内，如果需要在其他文件内使用，就需要重新定义或者复制粘贴，这可能会导致代码的冗余和不一致。
静态函数不是线程安全的，如果多个线程同时调用同一个函数，可能会造成数据的混乱和竞争，因此需要加锁或者使用线程局部存储（thread local storage）来保护。