编辑“︁C++ 存储类”︁

= C++存储类 =

'''存储类'''（Storage Class）是C++中用于定义变量或函数的生命周期（作用域）和可见性的关键概念。它决定了程序在内存中如何分配、访问和管理数据。理解存储类对于编写高效、可维护的代码至关重要。

== 存储类概述 ==

在C++中，存储类通过关键字来指定，主要包括以下几种：
* '''auto'''（C++11起已弃用，仅用于类型推导）
* '''register'''（已弃用）
* '''static'''
* '''extern'''
* '''thread_local'''（C++11引入）
* '''mutable'''

这些关键字控制变量的存储位置（栈、堆、静态存储区等）、作用域（局部或全局）和生命周期（程序运行期间或函数调用期间）。

== 主要存储类详解 ==

=== auto ===

在C++11之前，'''auto'''用于声明自动变量（默认存储类），但从C++11起，它主要用于'''类型推导'''。

<syntaxhighlight lang="cpp">
// C++11 auto示例
auto x = 5;      // x被推导为int
auto y = 3.14;   // y被推导为double
</syntaxhighlight>

=== static ===

'''static'''关键字使变量在程序整个生命周期内存在，但作用域受限：
* 在'''函数内'''：变量在多次函数调用间保持值
* 在'''全局作用域'''或'''命名空间'''：变量仅在当前文件可见

<syntaxhighlight lang="cpp">
#include <iostream>

void counter() {
    static int count = 0; // 只初始化一次
    ++count;
    std::cout << "Count: " << count << "\n";
}

int main() {
    counter(); // 输出: Count: 1
    counter(); // 输出: Count: 2
    counter(); // 输出: Count: 3
}
</syntaxhighlight>

=== extern ===

'''extern'''用于声明（而非定义）在其他文件中定义的变量或函数：

<syntaxhighlight lang="cpp">
// file1.cpp
int globalVar = 42; // 定义

// file2.cpp
extern int globalVar; // 声明

int main() {
    std::cout << globalVar; // 输出: 42
}
</syntaxhighlight>

=== thread_local ===

C++11引入的'''thread_local'''表示变量具有线程存储期，每个线程有自己独立的实例：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <thread>

thread_local int tls_var = 0;

void foo() {
    ++tls_var;
    std::cout << "Thread " << std::this_thread::get_id() 
              << ": " << tls_var << '\n';
}

int main() {
    std::thread t1(foo); t1.join();
    std::thread t2(foo); t2.join();
}
/* 可能输出:
Thread 140737297899264: 1
Thread 140737289506560: 1
*/
</syntaxhighlight>

=== mutable ===

'''mutable'''允许const对象的成员变量被修改：

<syntaxhighlight lang="cpp">
class Example {
    mutable int counter;
public:
    void increment() const { ++counter; } // 合法
};
</syntaxhighlight>

== 存储类比较 ==

<mermaid>
flowchart TD
    A[存储类] --> B[auto]
    A --> C[register]
    A --> D[static]
    A --> E[extern]
    A --> F[thread_local]
    A --> G[mutable]
    D --> D1[局部静态]
    D --> D2[全局静态]
</mermaid>

{| class="wikitable"
|+ 存储类特性比较
! 存储类 !! 生命周期 !! 作用域 !! 初始化
|-
| auto || 块作用域 || 局部 || 每次进入块时
|-
| register || 块作用域 || 局部 || 每次进入块时
|-
| static || 程序整个运行期 || 局部或文件 || 只初始化一次
|-
| extern || 程序整个运行期 || 全局 || 在别处定义
|-
| thread_local || 线程生命周期 || 根据声明位置 || 每个线程独立
|-
| mutable || 同包含它的对象 || 同包含它的对象 || 同包含它的对象
|}

== 实际应用案例 ==

'''场景：'''实现一个多线程安全的计数器

<syntaxhighlight lang="cpp">
#include <iostream>
#include <vector>
#include <thread>

class Counter {
    static int total;            // 所有实例共享
    thread_local static int tls; // 每个线程独立
public:
    void increment() {
        ++total;
        ++tls;
    }
    void print() const {
        std::cout << "Total: " << total 
                  << ", Thread-local: " << tls << '\n';
    }
};

int Counter::total = 0;
thread_local int Counter::tls = 0;

int main() {
    std::vector<std::thread> threads;
    Counter c;

    for (int i = 0; i < 5; ++i) {
        threads.emplace_back([&c] {
            for (int j = 0; j < 3; ++j) {
                c.increment();
                c.print();
            }
        });
    }

    for (auto& t : threads) t.join();
}
/* 示例输出:
Total: 1, Thread-local: 1
Total: 2, Thread-local: 2
Total: 3, Thread-local: 3
Total: 4, Thread-local: 1
Total: 5, Thread-local: 2
... (输出顺序可能不同)
*/
</syntaxhighlight>

== 数学表示 ==

静态变量的内存分配可以表示为：

<math>
M_{static} = \begin{cases} 
\text{已初始化} & \text{在.data段} \\
\text{未初始化} & \text{在.bss段}
\end{cases}
</math>

其中.data段包含显式初始化的静态变量，.bss段包含未初始化或零初始化的静态变量。

== 最佳实践 ==

1. 优先使用'''自动存储期'''（默认）变量，除非需要特殊生命周期
2. 谨慎使用'''全局变量'''（通过extern或static），因为它们会增加耦合度
3. 多线程环境下考虑'''thread_local'''替代静态变量
4. '''mutable'''应仅用于逻辑上可变的缓存或标记，而非对象的核心状态
5. 现代C++中避免使用已弃用的'''auto'''和'''register'''

== 常见问题 ==

'''Q: static局部变量和全局变量有什么区别？'''
A: static局部变量只在声明它的函数内可见，但生命周期与程序相同；全局变量在所有文件中可见（除非用static限制）。

'''Q: 为什么需要thread_local？'''
A: 在多线程程序中，普通静态变量是共享的，可能导致竞争条件。thread_local为每个线程提供独立副本。

'''Q: extern和头文件包含有何区别？'''
A: extern是声明而非定义，不导致重复定义错误；头文件包含可能导致重复定义（除非使用include guards）。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 基础]]