C 作用域规则

C - 作用域规则 (Scope Rules)

作用域（Scope）定义了程序中声明的标识符（如变量或函数名称）可访问或“可见”的区域。理解作用域对于避免命名冲突和有效管理数据至关重要。

在 C 语言中，主要有三个级别的作用域：

块作用域（Block Scope / Local Scope）： 在块 {...} 内（如函数内部、循环或 if 语句内部）声明的标识符仅从声明点到该块的末尾可访问。
函数作用域（Function Scope）： 仅适用于标签（与 goto 一起使用）。无论块如何嵌套，标签在其定义所在的整个函数中都可见。
文件作用域（File Scope / Global Scope）： 在任何函数外部声明的标识符具有文件作用域。它们从声明点到整个源文件末尾都可访问。

我们通常将变量称为“局部变量”和“全局变量”，这分别与块作用域和文件作用域密切相关。函数参数也具有作用域。

局部变量（块作用域）

在函数或任何块（{}）内声明的变量是局部变量。它们默认具有块作用域（Block Scope）和自动存储期（Automatic Storage Duration）。

可见性： 仅在其定义的块内可访问。
生命周期（自动存储期）： 它们在进入块时创建，在退出块时销毁。它们的内存通常分配在栈（stack）上。
初始化： 如果未显式初始化，它们的初始值是不确定的（垃圾值）。读取未初始化的局部变量会导致未定义行为（undefined behavior）。始终在使用前初始化局部变量。

#include <stdio.h>

void test_scope() {
    int x = 10; // x has block scope within test_scope
    // x 在 test_scope 函数内具有块作用域
    printf("Inside test_scope, x = %d\n", x);

    if (x > 5) {
        int y = 20; // y has block scope within the if block
        // y 在 if 块内具有块作用域
        // x is also accessible here
        // x 在这里也是可访问的
        printf("Inside if block, x = %d, y = %d\n", x, y);
    }
    // printf("Trying to access y outside its scope: %d\n", y); // COMPILE ERROR! y is not visible here.
    // 尝试在 y 的作用域外访问 y：编译错误！y 在这里不可见。
}

int main(void) {
    int a = 5; // a has block scope within main
    // a 在 main 函数内具有块作用域
    printf("Inside main, a = %d\n", a);
    // printf("Trying to access x from main: %d\n", x); // COMPILE ERROR! x is not visible here.
    // 尝试从 main 函数访问 x：编译错误！x 在这里不可见。
    test_scope();
    return 0;
}

全局变量（文件作用域）

在任何函数外部声明的变量具有文件作用域（File Scope）和静态存储期（Static Storage Duration）。

可见性： 从声明点到文件末尾都可访问。如果声明时没有使用 static 关键字（外部链接性），它们还可以从其他文件访问。
生命周期（静态存储期）： 它们存在于整个程序执行期间。它们的内存分配在不同的段（例如，数据段 data segment 或 BSS 段）。
初始化： 如果未显式初始化，它们会自动被系统初始化为零（或其等价形式：算术类型为 0，char 为 '�'，浮点类型为 0.0，指针为 NULL）。

注意： 通常不鼓励过度使用全局变量。由于程序中任何地方都可能修改它们（副作用 side effects），并且增加了命名冲突的风险，它们会使代码更难理解、调试和维护。

#include <stdio.h>

// Global variable declaration (file scope)
// 全局变量声明 (文件作用域)
int global_count = 100; // Explicitly initialized
// 显式初始化
double global_value; // Implicitly initialized to 0.0
// 隐式初始化为 0.0

void increment_global() {
    global_count++;
    printf("Inside increment_global: global_count = %d\n", global_count);
}

void print_globals() {
    printf("Inside print_globals: global_count = %d, global_value = %.1f\n",
           global_count, global_value);
}

int main(void) {
    printf("Initial main: global_count = %d\n", global_count);
    increment_global();
    print_globals();

    global_count = 50; // Can be accessed and modified from main
    // 可以从 main 函数访问和修改
    printf("After modification in main: global_count = %d\n", global_count);
    print_globals();

    return 0;
}

遮蔽 (Shadowing)

如果一个局部变量与一个全局变量具有相同的名称，那么局部变量在其作用域内会**遮蔽（shadow）**全局变量。在该块内部，该名称引用局部变量。

#include <stdio.h>

int g = 20; // Global variable
// 全局变量

int main(void) {
    printf("Accessing global g before local declaration: %d\n", g); // Accesses global g
    // 在局部变量声明前访问全局 g

    int g = 10; // Local variable, shadows the global g
    // 局部变量，遮蔽全局 g

    printf("Accessing local g: %d\n", g); // Accesses local g
    // 访问局部 g

    {
        int g = 5; // Another local g, shadows the previous local g
        // 另一个局部 g，遮蔽上一个局部 g
        printf("Accessing inner local g: %d\n", g);
        // 访问内部局部 g
    } // Inner g goes out of scope
    // 内部 g 超出作用域

    printf("Accessing outer local g again: %d\n", g); // Accesses the g=10 local
    // 再次访问外部局部 g

    // No direct way to access the global g here without special techniques (like extern)
    // 在这里没有直接的方式可以不使用特殊技术（如 extern）访问全局 g
    return 0;
}

输出：

Accessing global g before local declaration: 20
Accessing local g: 10
Accessing inner local g: 5
Accessing outer local g again: 10

形式参数（函数参数作用域）

在函数定义中声明的参数，其作用域仅限于该函数块。它们的行为类似于局部变量，并使用函数调用期间传递的值进行初始化。

它们可以遮蔽同名的全局变量。

#include <stdio.h>

int a = 20; // Global variable
// 全局变量

// Function definition with parameters 'a' and 'b'
// 包含参数 'a' 和 'b' 的函数定义
int sum(int a, int b) { // 'a' here is the parameter, shadows global 'a'
    // 这里的 'a' 是参数，遮蔽了全局 'a'
    printf("Inside sum: parameter a = %d\n", a); // Accesses parameter a
    // 访问参数 a
    printf("Inside sum: parameter b = %d\n", b);
    // printf("Inside sum: global a = %d\n", ::a); // Not standard C to access global like this
    // 在 C 中这样访问全局变量不是标准写法
    return a + b; // Uses parameter 'a'
    // 使用参数 'a'
}

int main(void) {
    int a = 10; // Local variable in main, shadows global 'a'
    // main 函数中的局部变量，遮蔽全局 'a'
    int b = 5;
    int result;

    printf("Inside main: local a = %d\n", a); // Accesses main's local 'a'
    // 访问 main 的局部 'a'
    printf("Inside main: global a (not directly accessible by name)\n");
    // main 函数中：全局 a（无法通过名称直接访问）

    result = sum(a, b); // Pass main's local 'a' (value 10)
    // 传递 main 的局部 'a'（值为 10）

    printf("Inside main: result = %d\n", result);

    return 0;
}

输出：

Inside main: local a = 10
Inside main: global a (not directly accessible by name)
Inside sum: parameter a = 10
Inside sum: parameter b = 5
Inside main: result = 15

初始化局部变量和全局变量

根据存储期（Storage Duration）的不同，初始化规则也不同：

局部变量（自动存储期 Automatic Storage Duration）： 必须由程序员显式初始化。如果未初始化，其值是不确定的（垃圾值），读取它们会导致未定义行为（undefined behavior）。
全局变量和静态局部变量（静态存储期 Static Storage Duration）： 如果未提供显式初始化器，系统会自动初始化它们。默认初始值为零（或其等效形式：算术类型为 0，char 为 '�'，浮点类型为 0.0，指针为 NULL）。

静态/全局变量的默认初始化：

数据类型 (Data Type)	默认初始值 (Default Initial Value)
`int`, `short`, `long`, `long long`, `char`, `_Bool`	0
`float`, `double`, `long double`	0.0
Pointer types	`NULL` (typically equivalent to `(void *)0`)

最佳实践： 始终显式初始化您的变量，尤其是局部变量，以避免意外行为并使您的代码更清晰。