C++ 的关键字（保留字）完整介绍

C++关键字是语言预留的特殊单词，不能用作变量名、函数名等。它们控制程序的行为、类型、流程等。

1. 基本数据类型（最常用）

关键字	含义（初学者版）	示例 / 说明	注意事项
bool	布尔类型，只有true / false	`bool ok = true;`	条件判断核心
char	单个字符（通常1字节）	`char c = 'A';`	用单引号
wchar_t	宽字符（常用于支持中文等）	`wchar_t wc = L'中';`	2或4字节，视平台
char8_t	UTF-8字符（C++20新增）	`char8_t c8 = u8'好';`	现代Unicode编程
char16_t	UTF-16字符（C++11）
char32_t	UTF-32字符（C++11）
int	整数（通常4字节）	`int age = 18;`	最常用整数类型
short	短整数（通常2字节）	`short s = 1000;`	节省空间时用
long	长整数（至少4字节，常见8字节）	`long l = 1234567890L;`	加L后缀
long long	更长的整数（至少8字节，C++11正式）	`long long big = 1LL<<60;`	处理大数字
float	单精度浮点数	`float f = 3.14f;`	加f后缀
double	双精度浮点数（默认浮点类型）	`double pi = 3.1415926535;`	精度更高
void	无类型（函数不返回值、指针泛型等）	`void func();`	常见于函数声明
unsigned	无符号（与int/long等组合）	`unsigned int id = 4000000000u;`	范围更大，但不能表示负数

2. 变量/对象生命周期与存储（Storage & Duration）

关键字	含义（初学者版）	示例 / 常见用法	现代建议
auto	让编译器自动推导类型（C++11后最重要用法）	`auto x = 3.14;` → double	强烈推荐，写代码最常用
const	常量，不可修改	`const int MAX = 100;`	比#define更安全，有类型检查
static	静态存储（文件内共享、类成员共享、函数内保持值）	`static int count = 0;`	类静态成员需类外初始化
extern	声明变量/函数在别处定义（跨文件使用）	`extern int globalVar;`	常用于多文件项目
thread_local	每个线程拥有自己的一份（C++11）		多线程编程
register	建议放寄存器（现代编译器基本忽略）		基本不用，已过时
mutable	允许const成员函数修改该成员		类内特殊场景

3. 类与面向对象核心（OOP基础）

关键字	含义（初学者版）	示例 / 说明	重要程度
class	定义类（默认private）	`class Student { ... };`	★★★★★
struct	定义结构体（默认public，与C兼容）	`struct Point { int x,y; };`	★★★★
public	公有成员，谁都可以访问
private	私有成员，只有本类和友元能访问
protected	受保护成员，本类 + 子类 + 友元可访问
this	指向当前对象的指针	`this->age = 18;`	常用于区分同名参数
friend	友元（允许访问private/protected）	`friend class Utils;`	用得少，慎用破坏封装
virtual	虚函数（实现多态）	`virtual void draw() = 0;`	多态核心
override	显式声明这是重写（C++11，推荐加）	`void draw() override;`	防止拼写错误
final	禁止继承/禁止重写（C++11）	`class My final {}`	设计意图明确
explicit	禁止隐式转换（单参数构造函数最常见）	`explicit MyClass(int x);`	防止意外转换

4. 内存管理与指针相关

关键字	含义（初学者版）	示例 / 说明	现代建议
new	动态分配内存（返回指针）	`int* p = new int(5);`	尽量用智能指针
delete	释放new分配的内存	`delete p; delete[] arr;`	配对使用，避免内存泄漏
nullptr	空指针常量（C++11，推荐替代NULL）	`int* ptr = nullptr;`	强烈推荐

5. 强制类型转换（4种cast，安全性递减）

关键字	含义（初学者版）	安全性	建议使用场景
static_cast	编译期转换（相关类型、数值转换等）	高	日常最常用
const_cast	加/去const或volatile	中	极少用，危险
dynamic_cast	运行时安全向下转型（多态类）	高	继承体系中检查类型
reinterpret_cast	低级、危险的位模式重新解释（指针间任意转换）	低	极少用（如硬件交互）

6. 流程控制（最基础）

关键字	含义（初学者版）	示例
if / else	条件判断（满足条件执行，否则执行另一部分）	`int a = 8; if (a > 10) { cout << "大于10"; } else { cout << "不大于10"; }`
switch	多分支选择（仅支持整数/枚举/char类型）	`int score = 9; switch (score) { case 9: cout << "优秀"; break; default: cout << "普通"; }`
case / default	switch内的分支标签（case匹配值，default匹配所有未命中情况）	`char ch = 'a'; switch (ch) { case 'a': cout << "字母A"; break; default: cout << "其他字符"; }`
for	计数/范围循环（适合已知循环次数的场景）	`for (int i=0; i<10; i++) { cout << i; }`（计数循环） `vector<int> v={1,2,3}; for (int num : v) { cout << num; }`（范围循环）
while	先判断后执行（未知循环次数，条件满足才循环）	`int i=1; while (i<=5) { cout << i; i++; }`
do	先执行至少一次，再判断（未知循环次数，确保首次执行）	`int i=1; do { cout << i; i++; } while (i<=5);`
break	跳出当前循环/switch分支（直接终止，不执行后续内容）	`for (int i=0; i<10; i++) { if (i==5) break; cout << i; }`（跳出循环） `switch (score) { case 9: break; }`（跳出switch分支）
continue	跳过本次循环剩余部分，直接进入下一次循环	`for (int i=0; i<10; i++) { if (i%2==0) continue; cout << i; }`（仅打印奇数）
return	返回函数结果（有返回值函数）或提前结束void函数	`int add(int a, int b) { return a + b; }`（返回函数结果） `void print() { if (1) return; cout << "此行不会执行"; }`（提前结束void函数）

7. 异常处理（现代C++仍常用，但不是首选）

try / catch / throw

8. 模板与现代泛型（中高级）

template、typename、concept（C++20）、requires（C++20）

9. 其他重要但不那么频繁出现的

constexpr（C++11）：编译期常量/函数
inline：建议函数内联（现代常用于头文件定义）
enum：枚举（现代推荐enum class）
namespace / using：命名空间管理
sizeof：求类型/对象字节大小
typeid：运行时类型信息（很少用）
asm：内嵌汇编（极少用）
goto：跳转（强烈不推荐，破坏结构）
export：C++20前模板导出（现在基本无用）

实例

1. auto（自动类型推导

让编译器帮你写类型，代码更简洁，少犯错。

实例

#include <iostream>
#include <vector>
#include <string>

int main() {
auto a = 42; // 推导成 int
auto b = 3.14; // 推导成 double
auto c = "hello"; // 推导成 const char*
auto d = std::string("world"); // 推导成 std::string
auto vec = std::vector{1, 2, 3}; // 推导成 std::vector<int>

std::cout << a << " " << b << " " << c << " " << d << "\n";
for (auto x : vec) { // 范围for循环常用auto
std::cout << x << " ";
}
std::cout << "\n";
}

输出：

42 3.14 hello world
1 2 3

2. const（常量）

保护变量不被意外修改，写出更安全的代码。

实例

#include <iostream>

int main() {
const int MAX = 100; // 必须初始化，不能改
// MAX = 200; // 错误！不能修改

const double PI = 3.14159;
std::cout << "圆周率 ≈ " << PI << "\n";

int x = 10;
const int* p = &x; // 指针指向的内容不能改
// *p = 20; // 错误！
x = 30; // 但可以改x本身
std::cout << *p << "\n";
}

圆周率 ≈ 3.14159
30

3. static（静态）

让变量"活得更久"，常用于计数、共享数据。

实例

#include <iostream>

void counter() {
static int count = 0; // 只初始化一次，函数结束不销毁
count++;
std::cout << "第 " << count << " 次调用\n";
}

int main() {
counter(); // 1
counter(); // 2
counter(); // 3
}

输出：

第 1 次调用
第 2 次调用
第 3 次调用

4. nullptr（现代空指针）

比 NULL 更安全、更清晰，避免类型混淆。

实例

#include <iostream>

int main() {
int* p1 = NULL; // 老式（不推荐）
int* p2 = nullptr; // 现代C++推荐写法

if (p2 == nullptr) {
std::cout << "p2 是空指针\n";
}

// nullptr 只能赋给指针，不能赋给整数
// int x = nullptr; // 错误！
}

输出：

p2 是空指针

5. range-based for（for(auto : ) 范围for循环）

遍历容器最简单、最安全的方式。

实例

#include <iostream>
#include <vector>

int main() {
std::vector<int> scores {85, 92, 78, 95};

// 传统写法
for (size_t i = 0; i < scores.size(); ++i) {
std::cout << scores[i] << " ";
}
std::cout << "\n";

// 现代写法（推荐）
for (auto score : scores) {
std::cout << score << " ";
}
std::cout << "\n";

// 如果要修改元素，用引用
for (auto& score : scores) {
score += 5;
}
for (auto score : scores) {
std::cout << score << " ";
}
}

输出：

85 92 78 95 
85 92 78 95 
90 97 83 100

6. explicit（禁止隐式转换）

防止意外的类型转换导致bug，加explicit更严谨。

实例

#include <iostream>

class Distance {
private:
double meters;
public:
// explicit Distance(double m) : meters(m) {} // 加explicit更安全
Distance(double m) : meters(m) {} // 不加会隐式转换

double get() const { return meters; }
};

void print(double d) {
std::cout << "距离: " << d << " 米\n";
}

int main() {
Distance d = 500; // 如果构造函数不是explicit，这里允许
print(d); // 隐式把 Distance → double
// print(500); // 如果加了explicit，这行会报错
}

输出（无explicit时）：

距离: 500 米

7. override（显式重写虚函数）

写override能让编译器帮你检查是否真的重写了虚函数。

实例

#include <iostream>

class Animal {
public:
virtual void speak() const {
std::cout << "某种动物叫声\n";
}
};

class Dog : public Animal {
public:
void speak() const override { // 加override最安全
std::cout << "汪汪汪！\n";
}
};

int main() {
Animal* pet = new Dog();
pet->speak();
delete pet;
}

输出：

汪汪汪！

8. constexpr（编译期计算）

让计算在编译时完成，程序更快、更安全。

实例

#include <iostream>

constexpr int factorial(int n) {
return (n <= 1) ? 1 : n * factorial(n - 1);
}

int main() {
constexpr int f5 = factorial(5); // 编译期算出 120
std::cout << "5! = " << f5 << "\n";

int x = 6;
// constexpr int f6 = factorial(x); // 错误！x不是常量
std::cout << "6! = " << factorial(x) << "\n"; // 运行期计算也可以
}

输出：

5! = 120
6! = 720

9. using（命名空间 + 类型别名）

using既能简化命名空间，也能创造好读的类型别名。

实例

#include <iostream>
#include <vector>

// 传统typedef
typedef std::vector<int> IntVec;

// 现代using（更灵活，可模板化）
using StringVec = std::vector<std::string>;

int main() {
using std::cout; // 只引入cout
using std::endl;

IntVec v1 {1, 2, 3};
StringVec v2 {"苹果", "香蕉"};

cout << v1.size() << " " << v2.size() << endl;
}

输出：

3 2

10. enum class（强类型枚举）

比普通enum更安全，不会意外跟整数混用。

实例

#include <iostream>

enum class Color { Red, Green, Blue }; // 强类型，不会隐式转int

int main() {
Color c = Color::Green;

// if (c == 1) {} // 错误！不能直接跟int比
if (c == Color::Green) {
std::cout << "是绿色\n";
}

// 想转int必须显式转换
std::cout << "底层值: " << static_cast<int>(c) << "\n";
}

输出：

是绿色
底层值: 1