C语言关键字之Static-CSDN博客

本文链接：https://blog.csdn.net/qq_38716211/article/details/141598121

在一些.C文件中，总能看到static的字样，static作为关键字在 C 和 C++ 中具有重要的作用。它提供了多种使用方式，帮助程序员控制变量和函数的作用域和生命周期。以下是详细介绍。

1. 静态变量

1.1 在函数内部的静态变量

当一个变量被声明为“static”局部变量时，它的作用域仅限于声明它的函数内部，但它的生命周期却延续到程序终止。这意味着即使函数多次被调用，“static”局部变量也只会被初始化一次，其值会在函数调用之间保持不变。

#include <stdio.h>

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

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

解释：

counter 是一个静态变量，初始化为 0。
每次调用 incrementCounter 时，counter 的值都会增加，保持其状态。

1.2 在全局作用域的静态变量

当一个变量被声明为“static”全局变量时，它的作用域仅限于声明它的文件（源文件）内部，其他文件无法访问这个变量。这可以用来隐藏一些不希望被其他文件访问的全局变量。

#include <stdio.h>

static int globalCounter = 0; // 全局静态变量

void incrementGlobalCounter() {
    globalCounter++;
}

void printGlobalCounter() {
    printf("Global Counter: %d\n", globalCounter);
}

int main() {
    incrementGlobalCounter();
    incrementGlobalCounter();
    printGlobalCounter(); // 输出: Global Counter: 2
    return 0;
}

解释：

globalCounter 是一个全局静态变量，仅在该文件内部可见。
其他文件无法访问 globalCounter，这有助于避免命名冲突。

那么，问题来了

Q：如何在另外一个.c文件中访问全局静态变量？

A：使用extern 关键字，如下例程。

// file1.c
static int secret_value = 42; // 静态全局变量

void print_secret_value() 
{
     printf("Secret value: %d\n", secret_value);
}

// file2.c
extern void print_secret_value(); // 函数声明

int main() 
{
    print_secret_value(); // 可以访问 secret_value
    return 0;
}

解释：

使用 static 关键字定义的变量（如 secret_value）具有文件内部链接性，意味着该变量只能在定义它的文件中使用，无法被其他文件访问。
通过 extern 声明，其他文件可以调用定义在 file1.c 中的函数 print_secret_value，从而间接访问 secret_value 的值。这种设计有助于隐藏内部实现细节，提供良好的封装性。

2. 静态函数（static function）

当一个函数被声明为 "static"函数时，它的作用域仅限于声明它的文件(源文件)内部，其他文件无法访问这个函数。这可以用来隐藏一些不希望被其他文件调用的辅助函数。

// file1.c
static int calculate_sum(int a, int b) 
{ // 静态函数
    return a + b;
}

int get_result() 
{
    return calculate_sum(10, 20);
}

// file2.c
int main() 
{
    calculate_sum(10, 20); // 编译错误,calculate_sum 是静态函数
    return 0;
}

解释：

calculate_sum 是一个静态函数，只能在当前文件中使用。
试图在mian 函数中直接调用 calculate_sum将导致编译错误。

3. 静态数组

静态数组的大小在编译时已确定，并且它的生命周期贯穿整个程序运行期。

#include <stdio.h>

void storeValues() {
    static int values[5]; // 静态数组
    static int index = 0;

    if (index < 5) {
        values[index] = index * 10; // 存储值
        index++;
    }

    for (int i = 0; i < index; i++) {
        printf("Value[%d]: %d\n", i, values[i]);
    }
}

int main() {
    storeValues(); // 输出: Value[0]: 0
    storeValues(); // 输出: Value[0]: 0, Value[1]: 10
    storeValues(); // 输出: Value[0]: 0, Value[1]: 10, Value[2]: 20
    storeValues(); // 输出: Value[0]: 0, Value[1]: 10, Value[2]: 20, Value[3]: 30
    storeValues(); // 输出: Value[0]: 0, Value[1]: 10, Value[2]: 20, Value[3]: 30, Value[4]: 40
    return 0;
}

解释：

values是一个静态数组，生命周期贯穿整个程序运行期。
数组在每次调用 storeValues 时保持其状态。

4. 静态类成员变量/函数

在 C++ 中,当一个类成员变量或函数被声明为“static” 时,它不属于任何类的实例，而是属于整个类本身。这意味着静态成员可以在没有创建类实例的情况下访问和使用。

class MyClass {
   public:
       static int class_count;
       MyClass() {
           class_count++;
       }
       ~MyClass() {
           class_count--;
       }
   };

   int MyClass::class_count = 0; // 静态成员变量初始化

   int main() {
       std::cout << "Class count: " << MyClass::class_count << std::endl; // 0
       MyClass obj1, obj2, obj3;
       std::cout << "Class count: " << MyClass::class_count << std::endl; // 3
       return 0;
   }