返回专栏
· 16 分钟阅读

变量作用域与生命周期(Variable Scope & Lifetime)


1. 什么是变量作用域与生命周期?

变量作用域(Scope)和生命周期(Lifetime)是编程语言中两个密切相关、但不能混为一谈的概念。

作用域(Scope):规定程序中某个变量名称可以被访问或引用的代码区域。

生命周期(Lifetime):规定变量或对象从创建到销毁,或者从开始有效到结束有效的时间范围。

简单理解:

  • 作用域回答:在哪里可以访问这个名称?
  • 生命周期回答:这个对象在什么时候存在?

例如,C 语言:

#include <stdio.h>

int main() {
    int value = 100;

    {
        int number = 200;
        printf("%d\n", number);
    }

    printf("%d\n", value);

    return 0;
}

value 在整个 main 函数体内可见,number 只在内部代码块中可见。

在常见实现中,这两个局部变量的存储期都与程序执行过程中的自动存储期规则相关,但它们的名称作用域不同。

1.1 作用域与生命周期的区别

对比维度 作用域 Scope 生命周期 Lifetime
核心含义 名称的可见范围 对象或变量的有效存在时间
关注对象 标识符、名称绑定 对象、存储、资源
主要决定因素 代码结构、语言作用域规则 存储期、对象创建与销毁规则
典型边界 代码块、函数、模块、类 创建、构造、销毁、程序结束
主要影响 能否直接通过名称访问 能否安全地使用对象
常见问题 名称遮蔽、未定义名称 悬空引用、资源泄漏、提前销毁

二者并不总是同步变化。

例如,C++ 中可以通过指针访问动态分配的对象。即使创建对象的局部指针变量已经离开作用域,只要对象没有被释放,它仍然可能存在。

int* create() {
    int* ptr = new int(100);
    return ptr;
}

int main() {
    int* value = create();

    // create 中的 ptr 已经离开作用域
    // 但它指向的动态对象仍然存在

    delete value;
    return 0;
}

这里:

  • ptr 的作用域结束,局部指针变量不再可见。
  • ptr 的生命周期结束。
  • new 创建的整数对象仍然存在。
  • delete 执行后,动态对象的生命周期结束。

这是理解作用域与生命周期差异的关键例子。


2. 变量作用域的主要类型

不同语言对作用域的分类不完全相同。常见分类包括块作用域、函数作用域、局部作用域、全局作用域和模块作用域。

2.1 块作用域(Block Scope)

块作用域通常由一对花括号或其他代码块结构界定。

C 语言:

#include <stdio.h>

int main() {
    int outer = 10;

    {
        int inner = 20;

        printf("%d\n", outer);
        printf("%d\n", inner);
    }

    printf("%d\n", outer);

    // printf("%d\n", inner); // 错误:inner 不在当前作用域

    return 0;
}

内部代码块可以访问外部代码块中可见的变量,但外部代码块不能直接访问内部代码块声明的局部变量。

作用域结构:

flowchart TB
    A["main 函数作用域"] --> B["声明 outer"]
    A --> C["内部代码块"]
    C --> D["声明 inner"]
    C --> E["可以访问 outer"]
    C --> F["可以访问 inner"]
    A --> G["内部代码块结束"]
    G --> H["inner 名称不可见"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

块作用域常用于:

  • 限制临时变量的可见范围。
  • 避免变量名称污染外部代码。
  • 缩短局部变量的使用范围。
  • 配合 RAII 控制资源生命周期。

2.2 函数作用域(Function Scope)

函数作用域在不同语言中有不同含义,不能直接认为所有函数内部变量都具有函数作用域。

例如,在 C 语言中,标签(goto 使用的标识符)具有函数作用域;普通局部变量通常具有块作用域。

void test() {
    int value = 100;

label:
    value++;

    if (value < 105) {
        goto label;
    }
}

这里的 label 可以在整个函数内被引用,而 value 仍然遵循其所在代码块的作用域规则。

在 Python 等语言中,函数作用域通常指函数体内通过赋值创建的局部名称所处的命名空间规则。

2.3 局部作用域(Local Scope)

局部变量是在某个函数、方法或代码块内部声明的变量。

public void calculate() {
    int result = 100;

    System.out.println(result);
}

result 只能在其局部作用域中直接访问。

局部变量通常用于:

  • 保存临时计算结果。
  • 管理函数内部状态。
  • 降低不同函数之间的变量耦合。
  • 避免全局状态带来的副作用。

需要注意,局部变量的作用域与存储位置不是同一个概念。局部变量不一定全部存储在栈上,具体位置由语言实现、编译器优化和运行时决定。

2.4 全局作用域(Global Scope)

全局变量通常在函数或类之外声明,可以在更广泛的程序范围内访问。

C 语言:

#include <stdio.h>

int globalValue = 100;

void printValue() {
    printf("%d\n", globalValue);
}

int main() {
    printValue();
    return 0;
}

全局变量通常具有静态存储期,其存储持续时间覆盖整个程序执行期间。

优点:

  • 多个函数可以共享数据。
  • 适合保存程序级配置或共享状态。
  • 不需要通过多层函数参数传递。

缺点:

  • 增加模块之间的耦合。
  • 容易产生隐式依赖。
  • 多线程环境下可能出现数据竞争。
  • 测试和维护难度增加。

大型项目通常倾向于减少可变全局状态,通过参数传递、对象封装或依赖注入管理共享数据。

2.5 模块作用域(Module Scope)

模块作用域是现代编程语言中常见的组织方式。

例如 JavaScript:

const appName = "Reverie";

function start() {
    console.log(appName);
}

export { appName, start };

appName 和 start 在当前模块内部可见,并通过 export 暴露给其他模块。

模块作用域能够:

  • 限制名称的可见范围。
  • 减少全局命名冲突。
  • 隔离模块内部实现。
  • 明确模块之间的依赖关系。

不同语言的模块规则不同。例如 JavaScript 使用模块导入导出机制,Python 使用模块命名空间,Rust 使用模块树和可见性规则。


3. 词法作用域与动态作用域

作用域不仅决定变量在哪里可见,还决定名称引用最终绑定到哪个变量。

常见的作用域规则有词法作用域和动态作用域。

3.1 词法作用域(Lexical Scope)

词法作用域也称静态作用域(Static Scope)。

变量的绑定关系主要由源代码中的嵌套结构决定,而不是由函数在运行时从哪里被调用决定。

JavaScript 示例:

const value = "global";

function outer() {
    const value = "outer";

    function inner() {
        console.log(value);
    }

    return inner;
}

const fn = outer();

fn(); // outer

inner 定义在 outer 内部,因此它能够访问定义位置外层作用域中的 value。

即使 inner 在 outer 执行结束后才被调用,仍然可以访问对应的词法环境。

词法作用域的名称查找过程:

flowchart TB
    A["访问变量名称"] --> B{"当前词法作用域是否存在"}
    B -->|"是"| C["使用当前作用域绑定"]
    B -->|"否"| D["查找外层词法作用域"]
    D --> E{"是否找到绑定"}
    E -->|"是"| F["使用外层绑定"]
    E -->|"否"| G["继续向外查找"]
    G --> H{"是否到达作用域链顶层"}
    H -->|"否"| D
    H -->|"是"| I["名称解析失败"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

词法作用域是 JavaScript、Python、C、C++、Java、Go、Rust 等主流语言采用的主要名称绑定模型。

3.2 动态作用域(Dynamic Scope)

动态作用域根据函数调用链确定变量绑定关系。

也就是说,变量的含义可能取决于当前函数是从哪里被调用的。

可以用伪代码理解:

变量 value = "global"

函数 outer:
    变量 value = "outer"
    调用 inner

函数 inner:
    输出 value

调用 outer

在动态作用域规则下,inner 查找 value 时,会沿着运行时调用链查找,因此可能得到 outer。

而在词法作用域下,inner 的变量绑定由定义位置决定。

动态作用域在现代通用编程语言中较少作为默认规则,但某些语言特性、宏系统、动态变量机制或特殊执行环境可能提供类似行为。

3.3 两种作用域的区别

对比维度 词法作用域 动态作用域
名称绑定依据 源代码定义位置 运行时调用链
变量查找方式 沿词法嵌套结构查找 沿动态调用环境查找
结果可预测性 通常较高 依赖调用路径
编译期分析 更容易 通常更复杂
常见语言 JavaScript、Python、C、C++、Java、Rust 少数语言或特殊机制

4. 变量遮蔽(Variable Shadowing)

变量遮蔽是指内层作用域声明了与外层作用域同名的变量,使内层代码中的名称引用优先绑定到内层变量。

4.1 基本变量遮蔽

let value = 100;

function test() {
    let value = 200;

    console.log(value); // 200
}

test();

console.log(value); // 100

内层 value 遮蔽了外层 value,但两个变量并不是同一个对象或绑定。

4.2 嵌套作用域中的遮蔽

#include <iostream>

int main() {
    int value = 10;

    {
        int value = 20;

        std::cout << value << std::endl; // 20
    }

    std::cout << value << std::endl; // 10

    return 0;
}

内部代码块结束后,内部变量不再处于可见范围,外层名称重新成为当前可见绑定。

4.3 遮蔽与赋值的区别

遮蔽是创建新的名称绑定,赋值是修改已有变量的值。

let value = 10;

function test() {
    value = 20; // 修改外层变量
}

test();

与下面的代码不同:

let value = 10;

function test() {
    let value = 20; // 创建局部变量,遮蔽外层变量
}

4.4 不同语言的遮蔽规则

不同语言对同名变量的声明有不同限制。

语言 常见规则
C 内层代码块可以声明同名局部变量
C++ 内层作用域可以遮蔽外层名称
Java 局部变量不能随意重复声明遮蔽某些外层局部变量
JavaScript let、const 支持块级遮蔽;var 具有函数作用域
Python 函数内部赋值通常建立局部名称,除非使用 global 或 nonlocal
Go 支持短变量声明在特定作用域中创建新绑定,容易出现同名遮蔽
Rust 支持变量遮蔽,并允许重新声明同名变量

变量遮蔽在合理情况下可以提高代码局部性,但过度使用会增加阅读和调试成本。


5. 变量生命周期与存储期

生命周期描述变量或对象在什么时候存在、什么时候失效。

在 C 和 C++ 中,需要特别区分存储期(Storage Duration)与作用域。

存储期决定对象的存储持续时间,作用域决定名称的可见范围。

5.1 自动存储期(Automatic Storage Duration)

自动存储期通常用于局部变量。

void calculate() {
    int value = 100;
}

当程序进入相应代码块并执行变量定义时,变量的生命周期开始;离开对应代码块时,自动存储期对象的生命周期结束。

典型特点:

  • 生命周期通常与代码块执行相关。
  • 不需要手动释放普通局部变量。
  • 常见实现会使用栈帧管理相关存储。
  • 可能被编译器优化到寄存器或直接消除。

5.2 静态存储期(Static Storage Duration)

静态存储期对象在程序的整个执行期间持续存在。

C 语言:

#include <stdio.h>

int globalValue = 100;

void counter() {
    static int count = 0;

    count++;

    printf("%d\n", count);
}

int main() {
    counter();
    counter();
    counter();

    return 0;
}

输出:

1
2
3

count 的名称作用域位于 counter 函数内部,但它具有静态存储期。

这说明:

局部作用域不等于短生命周期。

静态局部变量的特点:

  • 名称只在函数内部可见。
  • 存储期覆盖整个程序执行期间。
  • 多次调用函数时保留之前的值。
  • 初始化规则取决于语言标准。

5.3 动态存储期(Dynamic Storage Duration)

动态存储期对象通过动态内存管理机制创建,其生命周期由程序或运行时的资源管理规则决定。

C++:

int* create() {
    int* ptr = new int(100);
    return ptr;
}

int main() {
    int* value = create();

    delete value;

    return 0;
}

动态对象不会因为创建它的函数返回而自动销毁。

它的生命周期通常从对象创建完成开始,到对象被销毁时结束。

5.4 线程存储期(Thread Storage Duration)

线程存储期对象与线程生命周期相关。

C++:

thread_local int threadValue = 0;

每个线程拥有自己的 threadValue 实例。对象通常在线程开始执行相关初始化后建立,并在线程结束时销毁。

适用于:

  • 线程局部状态。
  • 每个线程独立的缓存。
  • 线程上下文数据。
  • 避免多个线程直接共享某些可变状态。

5.5 C++ 四种存储期总结

存储期 生命周期 常见声明方式
自动存储期 相关代码块执行期间 普通局部变量
静态存储期 整个程序执行期间 全局变量、静态变量
动态存储期 动态创建到销毁 new、动态分配
线程存储期 线程生命周期 thread_local

注意:这是 C++ 的存储期分类。其他语言可能采用不同术语和对象生命周期模型。


6. 作用域与生命周期的组合关系

作用域和生命周期相互独立,但在实际程序中会产生多种组合。

6.1 局部作用域与自动存储期

void test() {
    int value = 100;
}
  • 名称作用域:当前函数代码块。
  • 存储期:自动存储期。
  • 生命周期:通常在代码块退出时结束。

这是最常见的局部变量模式。

6.2 局部作用域与静态存储期

void counter() {
    static int count = 0;
    count++;
}
  • 名称作用域:当前函数。
  • 存储期:静态存储期。
  • 生命周期:整个程序执行期间。

名称只在局部范围内可见,但对应对象长期存在。

6.3 局部指针与动态对象

int* create() {
    int* ptr = new int(100);
    return ptr;
}
  • ptr:局部名称,具有局部作用域。
  • ptr 对应的指针对象:自动存储期。
  • new 创建的整数对象:动态存储期。
  • 函数返回后:局部指针对象结束生命周期,动态整数对象仍然存在。

6.4 外部引用与对象生命周期

int& create() {
    int value = 100;
    return value;
}

函数返回后,value 已经结束生命周期,返回的引用失去有效目标。

这是典型的生命周期错误。

6.5 组合关系总结

场景 名称作用域 对象存储期 典型情况
普通局部变量 局部 自动 函数内部变量
静态局部变量 局部 静态 函数内部 static 变量
全局变量 文件或全局相关范围 静态 全局状态
动态对象 由指针或引用访问 动态 new 创建的对象
线程局部变量 由声明位置决定 线程 thread_local

理解这些组合,可以避免将变量名称的可见范围误认为对象实际存在的时间。


7. 闭包与生命周期

闭包(Closure)是理解作用域和生命周期的重要概念。

闭包通常指函数与其捕获的外部词法环境组合形成的结构。

7.1 闭包的基本概念

JavaScript:

function createCounter() {
    let count = 0;

    return function() {
        count++;
        return count;
    };
}

const counter = createCounter();

console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

createCounter 执行结束后,其函数调用已经返回,但内部函数仍然可以访问 count。

这是因为闭包保留了访问外部词法环境的能力。

7.2 闭包为什么能够访问外部变量?

普通函数调用结束后,其局部执行环境不再作为活动调用帧存在。

但如果内部函数仍然引用外部变量,运行时需要保证这些变量在后续调用中仍然可用。

因此,运行时可能保留相关词法环境中的绑定。

闭包的关系: