第7章作用域与生命周期

课程目录第7章作用域与生命周期

第7章：作用域与生命周期——变量到底活多久？

说实话，作用域和生命周期这个话题，我当年学C++的时候觉得特别枯燥。不就是变量能访问的范围和它活多久嘛，有啥好讲的？直到我在一个嵌入式项目里，因为一个全局变量被意外修改，排查了整整两天……嗯，从那以后我再也不敢小看这两个概念了。

今天咱们就好好聊聊：变量到底在哪儿能用？它什么时候出生，什么时候死亡？

7.1 作用域：你的变量在哪儿能被看见？

作用域，说白了就是变量的“可见范围”。你定义一个变量，不是所有地方都能访问它的。C++里主要有三种作用域：全局、局部、命名空间。

7.1.1 全局作用域

在函数外面定义的变量，就是全局变量。它从定义开始，到文件结束，所有函数都能访问它。

#include <iostream>
int g_count = 0;  // 全局变量

void funcA() {
    g_count++;  // 可以访问
}

void funcB() {
    g_count += 2;  // 也可以访问
}

int main() {
    funcA();
    funcB();
    std::cout << g_count << std::endl;  // 输出 3
    return 0;
}

⚠️ 注意：全局变量虽然方便，但千万别滥用。我见过一个项目，全局变量满天飞，最后改一个变量，整个程序都崩了。全局变量是魔鬼的糖果——甜，但有毒。

7.1.2 局部作用域

在函数内部或代码块（花括号{}）里定义的变量，就是局部变量。它只在那个块里有效。

void example() {
    int x = 10;  // 局部变量，只在 example 函数内有效
    if (x > 5) {
        int y = 20;  // y 只在 if 块内有效
        std::cout << x << " " << y << std::endl;
    }
    // std::cout << y;  // 错误！y 已经不存在了
}

我个人习惯是：变量尽量定义在最小的作用域里。这样代码清晰，也不容易出bug。

7.1.3 命名空间作用域

命名空间是C++用来解决名字冲突的利器。你可以把相关的变量、函数、类都放在一个命名空间里。

namespace MyLib {
    int value = 42;
    void print() {
        std::cout << "MyLib::print()" << std::endl;
    }
}

namespace YourLib {
    int value = 100;
    void print() {
        std::cout << "YourLib::print()" << std::endl;
    }
}

int main() {
    std::cout << MyLib::value << std::endl;   // 42
    std::cout << YourLib::value << std::endl; // 100
    MyLib::print();
    YourLib::print();
    return 0;
}

💡 小技巧：用 using 声明可以少打字，但别在头文件里用 using namespace std; 否则容易污染全局命名空间。我在团队里就因为这个被review过好几次……

7.2 生命周期：变量到底活多久？

作用域管的是“可见性”，生命周期管的是“存在时间”。C++里有三种存储方式：自动存储、静态存储、动态存储。

7.2.1 自动存储（栈上变量）

局部变量默认就是自动存储。它们在进入作用域时创建，离开作用域时自动销毁。

void func() {
    int a = 10;  // a 在栈上分配
    double b = 3.14;  // b 也在栈上
    // 函数结束时，a 和 b 自动销毁
}

你想想看，栈上的变量就像临时工——干完活就走人，不占地方。效率高，但你不能指望它长期存在。

7.2.2 静态存储（全局/静态变量）

静态存储的变量，在程序启动时分配，程序结束时才释放。它们“活”得最久。

int globalVar = 1;  // 全局变量，静态存储

void func() {
    static int staticVar = 0;  // 静态局部变量
    staticVar++;
    std::cout << staticVar << std::endl;
}

int main() {
    func();  // 输出 1
    func();  // 输出 2
    func();  // 输出 3
    return 0;
}

🔑 关键点：静态局部变量只初始化一次，之后每次调用都保留上一次的值。我在写计数器、缓存、单例模式时经常用到它。

7.2.3 动态存储（堆上变量）

用 new 和 delete 手动管理的变量，就是动态存储。你让它活多久，它就活多久。

int* p = new int(42);  // 在堆上分配
// 使用 p...
delete p;  // 手动释放
p = nullptr;  // 好习惯：置空

⚠️ 警告：动态内存一定要记得释放！我曾经在一个服务器程序里忘了 delete，结果内存泄漏，跑了三天就挂了。后来我改用智能指针（shared_ptr、unique_ptr），再也没出过这种问题。

7.3 static 与 extern 关键字

这两个关键字，初学者经常搞混。我当年也踩过坑，咱们一次说清楚。

7.3.1 static 的三种用法

使用场景	作用	示例
全局变量前	限制作用域为当前文件	`static int fileVar;`
局部变量前	延长生命周期为程序运行期间	`static int count = 0;`
函数前	限制函数作用域为当前文件	`static void helper();`

// file1.cpp
static int hiddenVar = 10;  // 只在 file1.cpp 可见
static void secretFunc() {  // 只在 file1.cpp 可见
    // ...
}

// file2.cpp
// 无法访问 hiddenVar 和 secretFunc

7.3.2 extern 的用法

extern 用来声明一个变量或函数是在别的文件中定义的。说白了就是“告诉编译器：这个东西在其他地方，别报错”。

// global.h
extern int sharedVar;  // 声明，不是定义
extern void sharedFunc();

// global.cpp
int sharedVar = 100;  // 定义
void sharedFunc() {
    std::cout << "shared function" << std::endl;
}

// main.cpp
#include "global.h"
int main() {
    std::cout << sharedVar << std::endl;  // 100
    sharedFunc();
    return 0;
}

💡 经验之谈：extern 和 static 是反着的。static 说“别让外面看见”，extern 说“这东西在外面”。我建议你在头文件里多用 extern 声明，在源文件里定义，这样结构清晰。

7.4 知识体系总览

下面这张图，把本章的核心内容串起来了。你可以把它当作一个快速参考。

7.5 避坑指南

最后，分享几个我踩过的坑，希望能帮你少走弯路。

全局变量初始化顺序问题：不同文件里的全局变量，初始化顺序是不确定的。我曾经在两个文件里互相依赖全局变量，结果程序启动就崩。解决方案：用函数返回局部静态变量代替。
static 局部变量不是线程安全的：多线程环境下，多个线程同时访问 static 局部变量会导致数据竞争。我建议加锁，或者用 thread_local。
忘记 delete 导致内存泄漏：这个我说过了。现在我的代码里几乎不用裸 new/delete，全换成智能指针。
extern 和定义混淆：extern 只是声明，不是定义。如果你在头文件里写了 int x; 而不是 extern int x;，多个文件包含这个头文件就会导致重复定义错误。

好了，作用域和生命周期就聊到这儿。记住一句话：变量不是你想用，想用就能用。搞清楚它在哪里可见、能活多久，你的代码就会少很多莫名其妙的bug。

📚 课程目录