C++ register 存储类详解

一、什么是 register 存储类？

register 是 C++ 的一个存储类关键字，最初的设计目的是：建议编译器将变量存储在 CPU 寄存器中，而不是普通内存（RAM）里。

为什么需要寄存器变量？

理解这个，先看一下存储速度层级：

CPU 寄存器  ← 最快（纳秒级）
     ↓
CPU 缓存 (L1/L2/L3)
     ↓
内存 (RAM)  ← 较慢
     ↓
硬盘        ← 最慢

寄存器直接在 CPU 内部，访问速度极快。对于频繁使用的变量（比如循环计数器），如果能放进寄存器，理论上能提升性能。

基本语法

#include <iostream>
using namespace std;

int main() {
    register int i;   // 建议编译器把 i 放进寄存器
    
    for (i = 0; i < 1000000; i++) {
        // 频繁访问 i，用 register 可能提速
    }
    
    cout << "循环结束，i = " << i << endl;
    return 0;
}

使用规则（小白必看）

register int x = 10;
int* p = &x;   // ❌ 错误！register 变量不能取地址

各 C++ 版本的支持情况

这里是重点，版本差异很大：

// C++17 编译时会看到这样的警告：
// warning: 'register' storage class specifier is deprecated in C++17
register int val = 5;  // ⚠️ C++17 弃用，C++20 建议不用

现代 C++ 为什么废弃它？

原因很现实：

1. 编译器比你聪明 — 现代编译器的优化能力远超手工指定，-O2/-O3 优化标志下，编译器自动决定哪些变量进寄存器，比程序员判断更准确
2. 寄存器数量有限 — CPU 寄存器就那么几个，编译器的寄存器分配算法（Register Allocation）会做最优安排
3. 弊大于利 — 历史证明，程序员手动指定 register 反而可能干扰编译器优化

   实际建议

   // ❌ 旧写法（不推荐）
   register int count = 0;
   for (register int i = 0; i < n; i++) {
       count += i;
   }
   
   // ✅ 现代 C++ 写法（直接写，让编译器优化）
   int count = 0;
   for (int i = 0; i < n; i++) {
       count += i;
   }
   // 编译时加 -O2 参数，效果比 register 更好
   

   ---

   一句话总结

   register 是 C++ 早期的"性能提示"关键字，用于建议编译器将变量放入 CPU 寄存器。C++17 已弃用，C++20 实际上不再有效。现代开发中不要使用它，交给编译器优化即可。

   如果你在维护老代码遇到 register 关键字，理解其含义就好，新代码里直接删掉它不影响功能。

   ---

   ---

   ---

   二、static 存储类

   核心特性

   static 变量的三大特点：
   1. 生命周期 = 程序整个运行期（不会随函数退出而销毁）
   2. 默认初始化为 0
   3. 只初始化一次

      用法一：局部静态变量

#include <iostream>
using namespace std;

void counter() {
    static int count = 0;  // 只初始化一次！
    count++;
    cout << "第 " << count << " 次调用" << endl;
}

int main() {
    counter();  // 输出：第 1 次调用
    counter();  // 输出：第 2 次调用
    counter();  // 输出：第 3 次调用
    return 0;
}

普通局部变量 vs static 局部变量对比：

void test() {
    int a = 0;        // 每次调用重置为 0
    static int b = 0; // 保留上次的值
    a++;
    b++;
    cout << "a=" << a << " b=" << b << endl;
}
// 连续调用3次输出：
// a=1 b=1
// a=1 b=2   ← b 累加了！
// a=1 b=3

用法二：静态全局变量（限制作用域）

// file1.cpp
static int secret = 42;  // 只在本文件可见，其他文件无法访问

// file2.cpp
extern int secret;  // ❌ 报错！static 全局变量不能被外部引用

用法三：类的静态成员（重要！）

class Student {
public:
    string name;
    static int totalCount;  // 静态成员变量，所有对象共享
    
    Student(string n) : name(n) {
        totalCount++;  // 每创建一个学生，总数+1
    }
    
    static int getTotal() {  // 静态成员函数
        return totalCount;
    }
};

// 类外初始化（必须！）
int Student::totalCount = 0;

int main() {
    Student s1("张三");
    Student s2("李四");
    Student s3("王五");
    
    cout << Student::getTotal() << endl;  // 输出：3
    return 0;
}

竞赛中 static 的典型应用

// 记忆化搜索（竞赛常用！）
int dp[1001][1001];
// 等价写法，全局数组默认就是 static 生命周期
// 局部大数组必须声明为 static 或放全局，否则栈溢出！

void solve() {
    static int memo[100005] = {};  // 避免栈溢出的技巧
}

三、extern 存储类

核心作用

跨文件共享变量/函数 — 告诉编译器"这个变量在别的文件里定义的"

extern 的本质：
声明（declaration） ≠ 定义（definition）
extern int x;   → 只是声明，说"x 存在于某处"
int x = 10;     → 这才是定义，真正分配内存

基本用法

// globals.cpp — 定义变量
int globalScore = 100;
string playerName = "玩家一";

// main.cpp — 使用其他文件的变量
extern int globalScore;      // 声明，不分配内存
extern string playerName;    // 声明

int main() {
    cout << playerName << ": " << globalScore << endl;
    return 0;
}

函数的 extern（其实默认就是 extern）

// math_utils.cpp
int add(int a, int b) {
    return a + b;
}

// main.cpp
extern int add(int a, int b);  // 可以这样声明（通常用头文件代替）
// 实际项目更推荐用 #include "math_utils.h"

extern "C"（重要！C/C++ 混用）

// 告诉 C++ 编译器：用 C 的命名规则编译这个函数
extern "C" {
    void c_function(int x);   // C 写的函数，C++ 来调用
}

竞赛中的注意点

// ⚠️ 竞赛单文件不需要 extern
// 但要理解：全局变量本质上就具有 extern 链接性

int n, m;  // 全局变量，整个文件所有函数都能访问

int main() {
    cin >> n >> m;
    // ...
}

四、mutable 存储类

核心作用

在 const 对象中，允许某个成员变量被修改

场景理解

class Cache {
public:
    int data;
    mutable int accessCount;  // 即使对象是 const，也能修改
    
    Cache(int d) : data(d), accessCount(0) {}
    
    int getData() const {     // const 函数
        accessCount++;        // ✅ 可以修改 mutable 成员
        return data;
    }
};

int main() {
    const Cache c(42);        // const 对象
    cout << c.getData() << endl;  // accessCount 被修改了，但合法！
    cout << "访问次数: " << c.accessCount << endl;  // 输出：1
    return 0;
}

实际应用场景

class LazyLoader {
private:
    mutable bool cached = false;
    mutable string cachedResult;
    
public:
    // 逻辑上是"只读"操作，但内部有缓存机制
    string getResult() const {
        if (!cached) {
            cachedResult = "计算中...（耗时操作）";
            cached = true;
        }
        return cachedResult;
    }
};

与 lambda 的结合（现代 C++）

int value = 10;

// lambda 默认捕获的变量是 const 的
auto f = [value]() mutable {  // mutable 让捕获的副本可修改
    value++;  // ✅ 可以修改（但不影响外部的 value）
    cout << value << endl;
};

f();  // 输出：11
cout << value << endl;  // 外部 value 仍是：10

五、thread_local 存储类

核心作用

每个线程都拥有该变量的独立副本 — 线程安全的"私有全局变量"

thread_local 变量的特点：
- 每个线程有自己的独立副本
- 线程创建时初始化，线程结束时销毁
- 线程间互不干扰

基本示例

#include <iostream>
#include <thread>
using namespace std;

thread_local int threadID = 0;  // 每个线程独立的变量

void worker(int id) {
    threadID = id;  // 只修改本线程的副本
    cout << "线程 " << threadID << " 正在工作" << endl;
}

int main() {
    thread t1(worker, 1);
    thread t2(worker, 2);
    thread t3(worker, 3);
    
    t1.join();
    t2.join();
    t3.join();
    // 三个线程的 threadID 互不影响
    return 0;
}

解决线程安全问题

// ❌ 非线程安全（多线程竞争同一变量）
int globalCounter = 0;
void unsafeIncrement() {
    globalCounter++;  // 多线程同时操作 → 数据竞争！
}

// ✅ 用 thread_local 让每个线程有自己的计数器
thread_local int localCounter = 0;
void safeIncrement() {
    localCounter++;  // 每个线程操作自己的副本，安全！
}

六、五大存储类对比总结

七、考级/竞赛重点速览

GESP 1-4级：认识 static 局部变量、extern 声明概念
GESP 5-6级：static 类成员、多文件 extern 使用
CSP-J：static 全局/局部变量（防栈溢出技巧重要！）
CSP-S / NOIP：static 在 DP 记忆化中的应用
NOI：多线程场景可能涉及 thread_local（高阶）

🏆 备考优先级：static > extern > mutable > thread_local > register