| 序号 | 语言 | 关键字 | 原型 | 实现原理 | 功能 | 返回值类型 | 使用示例 | 注意事项 | 应用场景 |
| 1 | C | auto | auto 数据类型 变量名; | 函数调用时在栈上分配内存，函数结束自动释放 | 声明自动变量，变量生命周期限于函数执行期间 | 无 | c<br>void func() {<br> auto int num = 10;<br> printf("%d\n", num);<br>}<br> | C 语言中局部变量默认是 auto，此关键字使用较少 | 在函数内部临时使用的变量，不希望其占用过多内存资源时使用 |
| 2 | C | break | break; | 执行时立即终止当前所在的 for、while、do - while 循环或 switch 语句 | 提前结束循环或 switch 语句，控制程序流程 | 无 | c<br>for (int i = 0; i < 10; i++) {<br> if (i == 5) {<br> break;<br> }<br> printf("%d ", i);<br>}<br> | 只能用于循环和 switch 语句 | 当在循环中满足某个条件，需要立即退出循环时使用；在 switch 语句中，用于跳出当前 case 分支 |
| 3 | C | case | case 常量表达式: 语句; | switch 表达式的值依次与 case 后的常量表达式比较，匹配则执行对应语句 | 在 switch 语句中提供多分支选择 | 无 | c<br>int num = 2;<br>switch (num) {<br> case 1:<br> printf("One\n");<br> break;<br> case 2:<br> printf("Two\n");<br> break;<br> default:<br> printf("Other\n");<br>}<br> | case 后必须是常量表达式，且不同 case 值不能重复 | 根据一个变量的不同取值执行不同的代码块，如菜单选择、状态判断等 |
| 4 | C | char | char 变量名; | 通常占用 1 字节内存，存储字符的 ASCII 码值 | 处理字符数据 | 作为函数返回类型时返回字符类型值 | c<br>char getChar() {<br> return 'A';<br>}<br> | 字符存储本质是整数，可进行算术运算 | 处理字符输入输出、字符串操作、字符编码转换等场景 |
| 5 | C | const | const 数据类型 变量名; | 编译器检查，防止对初始化后的变量修改 | 声明常量，提高代码安全性和可读性 | 无 | c<br>const int num = 10;<br>// num = 20; // 编译错误<br> | 常量一旦初始化不能修改，若通过指针绕过检查修改是未定义行为 | 定义一些固定不变的值，如圆周率、重力加速度等，防止在程序中意外修改 |
| 6 | C | continue | continue; | 跳过当前循环体剩余语句，直接进入下一次循环判断 | 控制循环流程，跳过不必要操作 | 无 | c<br>for (int i = 0; i < 10; i++) {<br> if (i % 2 == 0) {<br> continue;<br> }<br> printf("%d ", i);<br>}<br> | 只能用于循环语句 | 在循环中，当某个条件满足时，跳过当前循环的剩余部分，继续下一次循环，如筛选特定条件的数据 |
| 7 | C | default | default: 语句; | switch 表达式值与所有 case 不匹配时执行 | 为 switch 语句提供默认执行分支 | 无 | 见 case 示例 | default 可省略，位置不固定，但习惯放在最后 | 在 switch 语句中，当所有 case 条件都不满足时，执行默认的操作 |
| 8 | C | do | do { 语句块; } while (条件表达式); | 先执行一次循环体，再判断 while 条件，为真则继续循环 | 实现至少执行一次循环体的循环结构 | 无 | c<br>int i = 0;<br>do {<br> printf("%d ", i);<br> i++;<br>} while (i < 5);<br> | 循环体至少执行一次，条件判断在循环体之后 | 需要确保循环体至少执行一次的场景，如用户输入验证，先让用户输入一次，再判断输入是否合法 |
| 9 | C | double | double 变量名; | 通常占用 8 字节内存，提供高精度小数表示 | 处理高精度浮点数运算 | 作为函数返回类型时返回双精度浮点数 | c<br>double getDouble() {<br> return 3.14159;<br>}<br> | 浮点数比较不能直接用 ==，需考虑精度误差 | 在需要高精度计算的场景中使用，如科学计算、金融计算等 |
| 10 | C | else | if (条件表达式) { 语句块 1; } else { 语句块 2; } | if 条件为假时执行 else 后的语句块 | 为 if 语句提供另一执行分支 | 无 | c<br>int num = 5;<br>if (num > 10) {<br> printf("Greater than 10\n");<br>} else {<br> printf("Less than or equal to 10\n");<br>}<br> | else 必须和 if 配对使用 | 根据条件的真假执行不同的代码块，实现程序的分支逻辑 |
| 11 | C | enum | enum 枚举类型名 { 枚举常量 1, 枚举常量 2, ... }; | 定义一组命名常量，默认从 0 递增，可手动指定值 | 定义相关常量集合，提高代码可读性 | 作为函数返回类型时返回枚举类型值 | c<br>enum Color { RED, GREEN, BLUE };<br>enum Color getColor() {<br> return GREEN;<br>}<br> | 枚举常量本质是整数，可进行比较和赋值 | 用于定义一组相关的常量，如表示状态、颜色、星期等，使代码更具可读性和可维护性 |
| 12 | C | extern | extern 数据类型 变量名; 或 extern 返回类型 函数名(参数列表); | 编译时标记引用，链接阶段去其他文件查找定义 | 实现多文件间变量和函数共享 | 无 | c<br>// file1.c<br>#include <stdio.h><br>extern int num;<br>void print_num() {<br> printf("%d\n", num);<br>}<br>// file2.c<br>int num = 10;<br>#include <stdio.h><br>int main() {<br> print_num();<br> return 0;<br>}<br> | extern 只是声明，变量或函数定义必须在其他文件中 | 在大型项目中，多个文件需要共享变量或函数时使用 |
| 13 | C | float | float 变量名; | 通常占用 4 字节内存，用于表示小数 | 处理对精度要求不高的浮点数运算 | 作为函数返回类型时返回单精度浮点数 | c<br>float getFloat() {<br> return 2.71f;<br>}<br> | 单精度浮点数精度低于双精度，使用时需注意精度损失 | 在对精度要求不高，且需要节省内存的场景中使用，如游戏开发中的一些简单计算 |
| 14 | C | for | for (初始化表达式; 条件表达式; 循环后操作表达式) { 语句块; } | 先执行初始化表达式，再判断条件，为真则执行循环体和循环后操作，重复判断 | 实现已知循环次数的循环结构 | 无 | c<br>for (int i = 0; i < 5; i++) {<br> printf("%d ", i);<br>}<br> | 初始化、条件和循环后操作表达式可省略，但分号不能省略 | 当需要执行固定次数的循环时使用，如数组遍历、重复执行某段代码等 |
| 15 | C | goto | goto 标签名; 标签名: 语句; | 无条件跳转到指定标签处 | 特定情况下实现程序跳转 | 无 | c<br>int i = 0;<br>start:<br> printf("%d ", i);<br> i++;<br> if (i < 5) {<br> goto start;<br> }<br> | 过度使用会使代码结构混乱，可读性降低，应谨慎使用 | 在某些特定的错误处理场景中，需要快速跳转到错误处理代码处时使用 |
| 16 | C | if | if (条件表达式) { 语句块; } | 计算条件表达式值，为真则执行语句块 | 根据条件控制程序执行流程 | 无 | c<br>int num = 5;<br>if (num > 0) {<br> printf("Positive\n");<br>}<br> | 条件表达式结果必须是布尔值或可隐式转换为布尔值 | 根据不同的条件执行不同的代码块，实现程序的逻辑判断 |
| 17 | C | int | int 变量名; | 通常占用 4 字节内存，存储整数 | 处理整数运算 | 作为函数返回类型时返回整数类型值 | c<br>int getInt() {<br> return 10;<br>}<br> | 整数运算可能会溢出，需注意范围 | 在处理整数数据的场景中使用，如计数、索引等 |
| 18 | C | long | long 变量名; | 长度因系统而异，通常至少 4 字节，部分系统 8 字节 | 处理大范围整数运算 | 作为函数返回类型时返回长整数类型值 | c<br>long getLong() {<br> return 1000000L;<br>}<br> | 不同系统 long 长度可能不同，若需跨平台使用可考虑 long long | 在需要处理较大整数的场景中使用，如文件大小、时间戳等 |
| 19 | C | register | register 数据类型 变量名; | 建议编译器将变量存于寄存器，编译器可忽略 | 提高频繁访问变量的访问速度 | 无 | c<br>register int num = 10;<br>printf("%d\n", num);<br> | 不能对 register 变量取地址，因为它可能不在内存中 | 在需要频繁访问某个变量，且希望提高访问速度的场景中使用，如循环计数器 |
| 20 | C | return | return 表达式; 或 return;（函数返回类型为 void 时） | 从函数返回值并终止函数执行 | 将函数计算结果返回给调用者 | 由函数定义的返回类型决定 | c<br>int add(int a, int b) {<br> return a + b;<br>}<br> | 返回值类型必须与函数定义的返回类型一致 | 函数执行完后，将结果返回给调用者，结束函数的执行 |
| 21 | C | short | short 变量名; | 通常占用 2 字节内存，存储小范围整数 | 处理对内存要求高且整数范围小的情况 | 作为函数返回类型时返回短整数类型值 | c<br>short getShort() {<br> return 10;<br>}<br> | short 范围有限，使用时注意数据不要溢出 | 在对内存要求较高，且整数范围较小的场景中使用，如嵌入式系统开发 |
| 22 | C | signed | signed 数据类型 变量名; | 明确声明有符号类型变量，默认类型多为有符号 | 表示正数、负数和零 | 无 | c<br>signed int num = -10;<br>printf("%d\n", num);<br> | 可省略，因为多数类型默认是有符号的 | 在需要处理负数的场景中使用，明确表示变量可以为负数 |
| 23 | C | sizeof | sizeof(数据类型) 或 sizeof(变量名) | 编译时运算符，确定数据类型或变量占用内存字节数 | 了解数据内存占用，便于内存管理 | size_t 类型值 | c<br>int num;<br>size_t size = sizeof(num);<br>printf("Size of int: %zu bytes\n", size);<br> | sizeof 是运算符，不是函数 | 在动态内存分配、数组操作等场景中，需要了解数据类型或变量的内存大小时使用 |
| 24 | C | static | static 数据类型 变量名; 或 static 返回类型 函数名(参数列表); | 修饰局部变量时在静态存储区分配内存，函数结束不销毁；修饰全局变量和函数时限制作用域在当前文件 | 延长局部变量生命周期，限制全局变量和函数作用域 | 无 | c<br>void func() {<br> static int count = 0;<br> count++;<br> printf("%d\n", count);<br>}<br> | 静态变量只初始化一次 | 在函数内部需要记录状态，或者在文件内部需要限制变量和函数作用域时使用 |
| 25 | C | struct | struct 结构体名 { 成员列表; }; | 为结构体分配连续内存空间，成员按定义顺序存储 | 组织和管理相关数据 | 作为函数返回类型时返回结构体类型值 | c<br>struct Point {<br> int x;<br> int y;<br>};<br>struct Point getPoint() {<br> struct Point p = {1, 2};<br> return p;<br>}<br> | 结构体成员访问使用 . 运算符，指针访问使用 -> 运算符 | 将相关的数据组织在一起，形成一个整体，如表示一个人的信息（姓名、年龄、性别等） |
| 26 | C | switch | switch (表达式) { case 常量表达式: 语句; ... default: 语句; } | 计算表达式值，与 case 常量表达式比较，匹配则执行对应语句 | 提供多分支选择结构 | 无 | 见 case 示例 | switch 表达式只能是整数类型或枚举类型 | 根据一个变量的不同取值执行不同的代码块，当分支较多时，使用 switch 比 if - else 更清晰 |
| 27 | C | typedef | typedef 原数据类型 新类型名; | 为已有数据类型定义新名称，不创建新类型 | 提高代码可读性和可维护性 | 无 | c<br>typedef int Integer;<br>Integer add(Integer a, Integer b) {<br> return a + b;<br>}<br> | 新类型名遵循标识符命名规则 | 为复杂的数据类型定义一个简洁的别名，提高代码的可读性和可维护性 |
| 28 | C | union | union 共用体名 { 成员列表; }; | 所有成员共享同一块内存空间，大小取决于最大成员 | 不同时间使用不同类型数据，节省内存 | 作为函数返回类型时返回共用体类型值 | c<br>union Data {<br> int i;<br> float f;<br>};<br>union Data getData() {<br> union Data d;<br> d.i = 10;<br> return d;<br>}<br> | 同一时间只能使用共用体的一个成员，修改一个成员会影响其他成员 | 在需要节省内存，且不同类型的数据不会同时使用的场景中使用，如网络协议解析 |
| 29 | C | unsigned | unsigned 数据类型 变量名; | 声明无符号类型变量，只能表示非负数 | 扩大只处理非负数时变量的取值范围 | 无 | c<br>unsigned int num = 10;<br>printf("%u\n", num);<br> | 无符号类型不能表示负数，进行算术运算时需注意 | 在只需要处理非负数的场景中使用，如数组索引、计数器等 |
| 30 | C | void | void 函数名(参数列表); 或 void* 指针名; | 作为函数返回类型表示不返回值；作为参数列表表示不接受参数；作为指针类型表示通用指针 | 表示无返回值、无参数或通用指针 | 无 | c<br>void printMessage() {<br> printf("Hello, World!\n");<br>}<br> | void 指针不能直接解引用，需转换为具体类型 | 在函数不需要返回值，或者函数不接受参数的场景中使用；void* 指针可用于实现通用的数据结构 |
| 31 | C | volatile | volatile 数据类型 变量名; | 告诉编译器变量值可能被程序无法控制的方式改变，每次访问从内存读取 | 确保访问变量时获取最新值，避免编译器优化错误 | 无 | c<br>volatile int sensorValue;<br>// 假设传感器会更新 sensorValue 的值<br>printf("%d\n", sensorValue);<br> | 常用于硬件寄存器访问等场景 | 在访问可能被硬件、中断服务程序等外部因素修改的变量时使用，确保每次读取的是最新值 |
| 32 | C++ | alignas | alignas(对齐字节数) 数据类型 变量名; | 指定变量或类型的对齐方式，使数据存储起始地址为特定值倍数 | 优化内存布局，提高内存访问速度 | 无 | cpp<br>struct alignas(16) MyStruct {<br> int a;<br> int b;<br>};<br> | 对齐字节数必须是 2 的幂次方 | 在对内存访问性能要求较高的场景中使用，如高性能计算、图形处理等 |
| 33 | C++ | alignof | alignof(数据类型) | 获取变量或类型的对齐要求，返回 std::size_t 类型值 | 了解数据对齐要求，便于手动管理内存 | std::size_t 类型值 | cpp<br>struct MyStruct {<br> int a;<br> int b;<br>};<br>std::cout << "Alignment of MyStruct: " << alignof(MyStruct) << std::endl;<br> | 用于获取类型的对齐信息，帮助进行内存管理 | 在手动进行内存分配和管理时，需要了解数据类型的对齐要求 |
| 34 | C++ | asm | asm (汇编代码); | 在 C++ 代码中嵌入汇编语言代码 | 实现高性能或特定硬件相关操作 | 无 | cpp<br>#include <iostream><br>int main() {<br> int a = 10;<br> int b = 20;<br> int result;<br> asm (<br> "addl %%ebx, %%eax"<br> : "=a" (result)<br> : "a" (a), "b" (b)<br> );<br> std::cout << "Result: " << result << std::endl;<br> return 0;<br>}<br> | 汇编代码与具体平台相关，可移植性差 | 在需要实现高性能的计算、与硬件底层交互等场景中使用 |
| 35 | C++ | bool | bool 变量名; | 占用 1 字节内存，值为 true 或 false | 表示逻辑真和假，用于条件判断和逻辑运算 | 作为函数返回类型时返回布尔类型值 | cpp<br>bool isEven(int num) {<br> return num % 2 == 0;<br>}<br> | 布尔类型可隐式转换为整数，true 为 1，false 为 0 | 在逻辑判断、条件控制等场景中使用，如判断一个数是否为偶数、判断文件是否打开成功等 |
| 36 | C++ | catch | catch (异常类型 异常变量名) { 语句块; } | 捕获和处理异常，根据异常类型匹配 catch 块 | 实现异常处理机制，提高程序健壮性 | 无 | cpp<br>#include <iostream><br>void divide(int a, int b) {<br> if (b == 0) {<br> throw std::runtime_error("Division by zero");<br> }<br> std::cout << "Result: " << a / b << std::endl;<br>}<br>int main() {<br> try {<br> divide(10, 0);<br> } catch (const std::runtime_error& e) {<br> std::cout << "Exception caught: " << e.what() << std::endl;<br> }<br> return 0;<br>}<br> | catch 块按顺序匹配，异常对象生命周期在 catch 块内 | 在程序中可能出现异常的地方，捕获并处理异常，避免程序崩溃 |
| 37 | C++ | class | class 类名 { 成员列表; }; | 将数据和操作函数封装，编译器生成包含成员信息的结构体 | 实现数据封装、继承和多态 | 无 | cpp<br>class Rectangle {<br>private:<br> int length;<br> int width;<br>public:<br> Rectangle(int l, int w) : length(l), width(w) {}<br> int area() {<br> return length * width;<br> }<br>};<br> | 类的成员默认是 private 访问权限 | 在面向对象编程中，将数据和操作封装在一起，实现代码的复用和可维护性 |
| 38 | C++ | constexpr | constexpr 返回类型 函数名(参数列表) { 函数体; } 或 constexpr 数据类型 变量名 = 表达式; | 声明常量表达式，编译时计算结果 | 编译时计算，减少运行时开销 | 作为函数返回类型时返回常量表达式 | cpp<br>constexpr int factorial(int n) {<br> return (n <= 1) ? 1 : n * factorial(n - 1);<br>}<br> | 函数体必须足够简单，能在编译时计算结果 | 在需要在编译时进行计算的场景中使用，如数组大小的确定、模板参数的计算等 |
| 39 | C++ | const_cast | const_cast<目标类型>(表达式); | 去除或添加指针或引用的 const 限定符 | 修改 const 对象属性，不改变类型 | 去除或添加 const 限定符的指针或引用 | cpp<br>const int num = 10;<br>int* nonConstPtr = const_cast<int*>(&num);<br>// *nonConstPtr = 20; // 未定义行为<br> | 修改 const 对象可能导致未定义行为，需谨慎使用 | 在某些特殊情况下，需要修改 const 对象的属性时使用 |
| 40 | C++ | decltype | decltype(表达式) 变量名; | 编译时推导表达式的类型 | 泛型和模板元编程中自动推导类型 | 无 | cpp<br>int a = 10;<br>decltype(a) b = 20;<br> | 根据表达式推导类型，可用于模板编程 | 在模板编程中，需要根据表达式的类型来定义变量或函数返回类型时使用 |
| 41 | C++ | delete | delete 指针名; 或 delete[] 指针名; | 释放 new 分配的内存 | 管理动态分配的内存 | 无 | cpp<br>int* ptr = new int(10);<br>delete ptr;<br> | delete 用于释放单个对象内存，delete[] 用于释放数组内存，不能重复释放 | 在使用 new 动态分配内存后，需要释放内存时使用，防止内存泄漏 |
| 42 | C++ | dynamic_cast | dynamic_cast<目标类型>(表达式); | 在继承体系中进行安全的向下转型，运行时检查类型 | 安全地将基类指针或引用转换为派生类指针或引用 | 目标类型的指针或引用 | cpp<br>class Base { virtual void func() {} };<br>class Derived : public Base {};<br>Base* basePtr = new Derived();<br>Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);<br> | 基类必须有虚函数，否则不能使用 dynamic_cast | 在继承体系中，需要将基类指针或引用转换为派生类指针或引用时使用，确保类型转换的安全性 |
| 43 | C++ | explicit | explicit 构造函数名(参数列表); | 防止构造函数进行隐式类型转换 | 避免意外的隐式类型转换 | 无 | cpp<br>class MyClass {<br>public:<br> explicit MyClass(int num) : data(num) {}<br>private:<br> int data;<br>};<br>// MyClass obj = 10; // 编译错误<br>MyClass obj(10);<br> | 用于单参数构造函数，防止隐式转换 | 在单参数构造函数中，不希望发生隐式类型转换时使用 |
| 44 | C++ | friend | friend 返回类型 函数名(参数列表); 或 friend class 类名; | 允许非成员函数或其他类访问类的私有和保护成员 | 提供特定的访问权限 | 无 | cpp<br>class MyClass {<br>private:<br> int data;<br> friend void printData(MyClass obj);<br>};<br>void printData(MyClass obj) {<br> std::cout << obj.data << std::endl;<br>}<br> | 破坏了类的封装性，应谨慎使用 | 在某些情况下，需要让非成员函数或其他类访问类的私有和保护成员时使用 |
| 45 | C++ | inline | inline 返回类型 函数名(参数列表) { 函数体; } | 建议编译器将函数代码直接嵌入调用处，减少函数调用开销 | 提高函数调用效率 | 由函数定义的返回类型决定 | cpp<br>inline int add(int a, int b) {<br> return a + b;<br>}<br> | 只是建议编译器内联，编译器可忽略 | 在函数体较小，且被频繁调用的场景中使用，提高程序的性能 |
| 46 | C++ | mutable | mutable 数据类型 成员变量名; | 允许在 const 成员函数中修改成员变量 | 在 const 对象中允许部分成员可修改 | 无 | cpp<br>class MyClass {<br>private:<br> mutable int count;<br>public:<br> void increment() const {<br> count++;<br> }<br>};<br> | 只能用于类的非静态成员变量 | 在 const 成员函数中，需要修改某些成员变量时使用 |
| 47 | C++ | namespace | namespace 命名空间名 { 成员列表; } | 定义命名空间，避免命名冲突 | 组织代码，避免全局命名冲突 | 无 | cpp<br>namespace MyNamespace {<br> int num = 10;<br>}<br>using namespace MyNamespace;<br>std::cout << num << std::endl;<br> | 可嵌套定义，使用 using 引入命名空间成员 | 在大型项目中，为了避免命名冲突，将相关的类、函数、变量等组织在不同的命名空间中 |
| 48 | C++ | new | 数据类型* 指针名 = new 数据类型; 或 数据类型* 指针名 = new 数据类型[数组大小]; | 动态分配内存并返回指向该内存的指针 | 动态管理内存 | 指向分配内存的指针 | cpp<br>int* ptr = new int(10);<br> | 使用 new 分配的内存必须使用 delete 释放，防止内存泄漏 | 在程序运行时需要动态分配内存的场景中使用，如创建对象、数组等 |
| 49 | C++ | noexcept | 返回类型 函数名(参数列表) noexcept; | 声明函数不会抛出异常 | 提高代码性能和可维护性 | 由函数定义的返回类型决定 | cpp<br>void func() noexcept {<br> // 不会抛出异常的代码<br>}<br> | 若函数声明 noexcept 但实际抛出异常，程序会调用 std::terminate | 在确保函数不会抛出异常的场景中使用，提高程序的性能和可维护性 |
| 50 | C++ | nullptr | 数据类型* 指针名 = nullptr; | 表示空指针，是一个类型安全的空指针常量 | 替代传统的 NULL，避免二义性 | 无 | cpp<br>int* ptr = nullptr;<br> | nullptr 是 C++11 引入的，用于替代 NULL | 在初始化指针时，使用 nullptr 明确表示指针为空，避免潜在的错误 |
| 51 | C++ | operator | 返回类型 operator 运算符(参数列表) { 函数体; } | 重载运算符，使自定义类型支持运算符操作 | 为自定义类型提供运算符功能 | 由函数定义的返回类型决定 | cpp<br>class MyClass {<br>public:<br> MyClass operator+(const MyClass& other) {<br> // 实现加法逻辑<br> }<br>};<br> | 部分运算符不能重载，如 .、::、?: 等 | 在自定义类型中，需要支持某些运算符操作时使用，如自定义复数类的加法、减法等 |
| 52 | C++ | private | 在类定义中使用，如 private: 成员列表; | 限制成员只能在类内部访问 | 实现数据封装，保护类的私有成员 | 无 | 见 class 示例 | 类的成员默认是 private 访问权限 | 在类中，需要保护某些成员不被外部访问时使用，实现数据的封装和隐藏 |
| 53 | C++ | protected | 在类定义中使用，如 protected: 成员列表; | 限制成员可在类内部和派生类中访问 | 实现数据封装，同时为派生类提供访问权限 | 无 | cpp<br>class Base {<br>protected:<br> int data;<br>};<br>class Derived : public Base {<br>public:<br> void accessData() {<br> data = 10; // 可访问<br> }<br>};<br> | 派生类可访问基类的 protected 成员 | 在类中，需要让派生类能够访问某些成员，但又不希望外部直接访问时使用 |
| 54 | C++ | public | 在类定义中使用，如 public: 成员列表; | 成员可在任何地方访问 | 提供类的公共接口 | 无 | 见 class 示例 | 公共成员可被外部代码直接访问 | 在类中，需要提供给外部使用的接口和功能时使用 |
| 55 | C++ | reinterpret_cast | reinterpret_cast<目标类型>(表达式); | 进行任意类型的指针或引用之间的转换，不进行类型检查 | 实现底层的类型转换 | 目标类型的指针或引用 | cpp<br>int num = 10;<br>int* ptr = #<br>char* charPtr = reinterpret_cast<char*>(ptr);<br> | 转换很危险，可能导致未定义行为，需谨慎使用 | 在某些底层编程场景中，需要进行不同类型指针或引用的转换时使用 |
| 56 | C++ | static_cast | static_cast<目标类型>(表达式); | 进行基本类型转换、父子类指针或引用转换等 | 实现常见的类型转换 | 目标类型的值 | cpp<br>int num = 10;<br>double d = static_cast<double>(num);<br> | 在有继承关系的指针或引用转换时，不进行运行时类型检查 | 在进行基本类型转换、父子类指针或引用转换等常见类型转换时使用 |
| 57 | C++ | template | template <模板参数列表> 返回类型 函数名(参数列表) { 函数体; } 或 template <模板参数列表> class 类名 { 成员列表; }; | 定义函数模板或类模板，实现泛型编程 | 编写与具体数据类型无关的代码 | 由函数或类的定义决定 | cpp<br>template <typename T><br>T max(T a, T b) {<br> return (a > b) ? a : b;<br>}<br> | 模板代码在编译时实例化 | 在编写通用的算法、数据结构等代码时使用，提高代码的复用性 |
| 58 | C++ | this | 在类的成员函数中使用 | 指向当前对象的指针 | 在成员函数中引用当前对象 | 指向当前对象的指针 | cpp<br>class MyClass {<br>private:<br> int data;<br>public:<br> void setData(int value) {<br> this->data = value;<br> }<br>};<br> | this 指针是隐式参数，不能修改 | 在类的成员函数中，需要引用当前对象的成员时使用 |
| 59 | C++ | thread_local | thread_local 数据类型 变量名; | 声明线程局部存储的变量，每个线程有独立副本 | 为每个线程提供独立的变量副本 | 无 | cpp<br>#include <iostream><br>#include <thread><br>thread_local int num = 0;<br>void func() {<br> num++;<br> std::cout << "Thread: " << std::this_thread::get_id() << ", num: " << num << std::endl;<br>}<br>int main() {<br> std::thread t1(func);<br> std::thread t2(func);<br> t1.join();<br> t2.join();<br> return 0;<br>}<br> | thread_local 变量生命周期与线程相同 | 在多线程编程中，每个线程需要独立的变量副本时使用 |
| 60 | C++ | throw | throw 异常对象; | 抛出异常，程序跳转到匹配的 catch 块 | 触发异常处理机制 | 无 | 见 catch 示例 | 抛出的异常对象必须能被某个 catch 块捕获 | 在程序中遇到错误或异常情况时，抛出异常，通知调用者进行处理 |
| 61 | C++ | try | try { 语句块; } catch (异常类型 异常变量名) { 语句块; } | 包含可能抛出异常的代码块，配合 catch 捕获异常 | 实现异常处理 | 无 | 见 catch 示例 | try 块后必须至少有一个 catch 块 | 在程序中可能出现异常的地方，使用 try - catch 块捕获并处理异常 |
| 62 | C++ | typeid | typeid(表达式) | 返回一个 std::type_info 对象，包含表达式的类型信息 | 在运行时获取类型信息 | std::type_info 对象引用 | cpp<br>#include <iostream><br>#include <typeinfo><br>int main() {<br> int num = 10;<br> std::cout << typeid(num).name() << std::endl;<br> return 0;<br>}<br> | 基类必须有虚函数，才能使用 typeid 进行运行时类型识别 | 在需要在运行时获取对象的类型信息时使用，如类型检查、类型转换等 |