C++常用关键字参考手册

基础类型

关键字	说明
`int`	整型（如 `int a = 5;`）
`char`	字符型（如 `char c = 'A';`）
`float`	单精度浮点数
`double`	双精度浮点数
`bool`	布尔值（`true`/`false`）
`void`	空类型（函数无返回值时使用）

类型修饰符

关键字	说明
`const`	定义常量（不可修改）
`unsigned`	无符号类型（如 `unsigned int`）
`signed`	有符号类型（默认）
`volatile`	防止编译器优化（多线程/硬件）
`mutable`	允许在 `const` 成员函数中修改成员

流程控制

关键字	说明
`if`/`else`	条件分支
`switch`	多路分支
`case`	`switch` 的分支标签
`default`	`switch` 的默认分支
`for`	循环
`while`	循环
`do`	循环（至少执行一次）
`break`	跳出循环/`switch`
`continue`	跳过当前循环的剩余代码
`return`	从函数返回

函数相关

关键字	说明
`inline`	建议编译器内联展开函数
`virtual`	声明虚函数（支持多态）
`override`	显式覆盖基类虚函数（C++11）
`final`	禁止派生类覆盖（C++11）
`auto`	自动类型推导（C++11）
`decltype`	查询表达式类型（C++11）

内存管理

关键字	说明
`new`	动态内存分配
`delete`	释放动态内存
`sizeof`	获取对象/类型大小（字节）

类与面向对象

关键字	说明
`class`	定义类
`struct`	定义结构体（默认公有继承）
`public`	公有成员访问权限
`private`	私有成员访问权限
`protected`	保护成员访问权限
`friend`	友元（允许访问私有成员）
`this`	指向当前对象的指针
`operator`	重载运算符
`explicit`	禁止隐式构造函数转换
`template`	定义模板（泛型编程）

异常处理

关键字	说明
`try`	尝试执行可能抛出异常的代码块
`catch`	捕获并处理异常
`throw`	抛出异常

命名空间

关键字	说明
`namespace`	定义命名空间（防止命名冲突）
`using`	引入命名空间或类型别名

其他重要关键字

关键字	说明
`static`	静态变量/函数（类内共享）
`extern`	声明外部全局变量
`constexpr`	编译期常量（C++11）
`nullptr`	空指针（替代 `NULL`，C++11）
`typename`	模板中声明依赖类型

代码示例

// ================ C++常用关键字示例 ================
// 此文件展示了C++核心关键字的用法
// 编译命令：g++ -std=c++17 keywords_demo.cpp -o demo

#include <iostream>
#include <vector>
#include <stdexcept>

// ===== 1\. 基础类型 & 类型修饰符 =====
const double PI = 3.14159;           // const常量
volatile int sensorValue;            // volatile防止优化

void basicTypes() {
    int integer = 42;                // int整型
    char letter = 'A';               // char字符
    float ratio = 0.618f;            // float浮点
    double pi = PI;                  // double浮点
    bool flag = true;                // bool布尔

    unsigned int positive = 100;     // unsigned无符号
    signed int normal = -50;         // signed有符号(默认)

    std::cout << "int: " << integer << ", char: " << letter << "\n";
}

// ===== 2\. 类 & 面向对象 =====
class Base {
public:                             // public访问权限
    virtual void print() const {    // virtual虚函数
        std::cout << "Base class\n";
    }
};

class Derived final : public Base { // final禁止继承
private:                            // private访问权限
    mutable int counter;            // mutable允许const修改
protected:                          // protected访问权限
    int id;
public:
    explicit Derived(int id) : id(id) {} // explicit禁止隐式转换

    void print() const override {   // override显式覆盖
        counter++;
        std::cout << "Derived " << id << "\n";
    }

    friend void friendFunc();       // friend友元函数
};

void friendFunc() {
    Derived d(99);
    d.counter = 0;  // 友元可访问private成员
}

// ===== 3\. 函数相关 =====
inline int add(int a, int b) {      // inline内联函数
    return a + b;
}

auto autoFunc() {                   // auto自动类型推导
    return "Hello from auto";
}

decltype(auto) declFunc() {         // decltype类型查询
    return add(2, 3);
}

// ===== 4\. 内存管理 =====
void dynamicMemory() {
    int* arr = new int[10];         // new动态分配
    delete[] arr;                   // delete释放内存
}

// ===== 5\. 流程控制 =====
void controlFlow(int x) {
    // if-else
    if (x > 100) {
        std::cout << "Large\n";
    } else {
        std::cout << "Small\n";
    }

    // switch
    switch(x) {
        case 0: std::cout << "Zero"; break;
        default: std::cout << "Non-zero"; break;
    }

    // for循环
    for (int i = 0; i < 5; ++i) {
        if (i == 2) continue;      // continue跳过当前
        std::cout << i << " ";
    }

    // while
    while (x > 0) {
        --x;
        if (x == 5) break;          // break跳出循环
    }

    // do-while
    do {
        x++;
    } while (x < 10);
}

// ===== 6\. 模板编程 =====
template <typename T>               // template模板
T max(T a, T b) {
    return (a > b) ? a : b;
}

template<typename U>
using Vec = std::vector<U>;         // using类型别名

// ===== 7\. 异常处理 =====
void riskyOperation() {
    try {
        throw std::runtime_error("Oops!"); // throw抛出异常
    } 
    catch (const std::exception& e) {   // catch捕获异常
        std::cerr << "Error: " << e.what();
    }
}

// ===== 8\. 命名空间 =====
namespace MyLib {                  // namespace命名空间
    void log() { std::cout << "Logging\n"; }
}

// ===== 9\. 其他关键字 =====
static int counter;                // static静态变量

constexpr int factorial(int n) {   // constexpr编译期计算
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

// ===== 主函数 =====
int main() {
    // 基础类型
    basicTypes();

    // 类与继承
    Derived d1(1);
    Base* b = &d1;
    b->print();

    // 函数特性
    std::cout << add(3, 4) << "\n";
    std::cout << autoFunc() << "\n";

    // 内存管理
    dynamicMemory();

    // 流程控制
    controlFlow(42);

    // 模板
    std::cout << max(3.14, 2.71) << "\n";
    Vec<int> nums = {1, 2, 3};

    // 异常
    riskyOperation();

    // 命名空间
    using namespace MyLib;          // using指令
    log();

    // 其他
    constexpr int fact5 = factorial(5);
    sizeof(int);                    // sizeof获取大小

    return 0;                      // return返回
}