C++ 常用关键字使用举例

// 1. 全局/命名空间：仅当前文件可见（避免跨文件重定义）
static int global_static = 10; // 其他文件无法通过 extern 访问
// 2. 局部变量：生命周期延长至程序结束（仅初始化1次）
void counter() {
    static int cnt = 0; 
    cnt++; 
    cout << cnt << " "; // 调用3次输出：1 2 3
}
// 3. 类成员：属于类（所有对象共享），需类外初始化
class Car {
public:
    static int total; // 声明
    static void printTotal() { cout << total << endl; } // 无 this 指针
};
int Car::total = 0; // 必须类外初始化（全局作用域）

// 1. 修饰变量：值不可改
const int MAX = 100; 
// MAX = 200; // 错误：const 变量禁止写入
// 2. 修饰指针（两种场景）
const int* p1;    // 指针指向的内容不可改（*p1 = 5 错误）
int* const p2 = &MAX; // 指针本身不可改（p2 = &x 错误）
const int* const p3; // 指针和内容均不可改
// 3. 修饰成员函数：保证不修改非 static 成员（this 变为 const T*）
class A {
    int x = 5;
public:
    void print() const { 
        // x = 10; // 错误：const 函数禁止修改成员
        cout << x << endl; 
    }
};
// 4. 修饰函数参数：防止函数内部修改实参
void func(const string& s) { 
    // s = "new"; // 错误：禁止修改参数
}

volatile int flag = 0; // 可能被其他线程/硬件修改
while (flag == 0) { 
    // 循环等待：每次从内存读 flag（而非寄存器缓存）
}

class Cache {
private:
    mutable int hit_count = 0; // 可在 const 函数中修改
public:
    int get_data() const {
        hit_count++; // 合法：hit_count 是 mutable
        return 42;
    }
};

// 1. 声明外部变量（file1.cpp 定义，file2.cpp 使用）
// file1.cpp: int global_val = 100;
extern int global_val; // file2.cpp 声明（无需初始化）
// 2. 调用 C 语言函数（避免 C++ 名称修饰）
extern "C" {
    #include "c_library.h" // C 头文件（如 printf）
}

#include <thread>
thread_local int thread_id = 0; // 每个线程有独立的 thread_id
void worker(int id) {
    thread_id = id; 
    cout << "Thread " << thread_id << endl; // 每个线程输出自己的 id
}
int main() {
    thread t1(worker, 1);
    thread t2(worker, 2);
    t1.join(); t2.join(); // 输出：Thread 1 \n Thread 2
}

class A { 
    int x; // 默认 private（仅类内访问）
};
struct B { 
    int y; // 默认 public（外部可直接访问）
};
// 继承权限区别
class C : A { ... }; // 继承默认 private（A 的 public 成员变为 C 的 private）
struct D : B { ... }; // 继承默认 public（B 的 public 成员仍为 D 的 public）

// 传统 enum：作用域全局，可隐式转换为 int（易冲突）
enum Color { RED, GREEN, BLUE };
Color c = RED;
int x = RED; // 隐式转换（不推荐）
// enum class（强类型）：作用域受限，无隐式转换（推荐）
enum class Direction { LEFT, RIGHT };
Direction d = Direction::LEFT; // 必须用 :: 访问
// int y = Direction::LEFT; // 错误：无隐式转换

// typedef 定义别名
typedef std::vector<int> IntVec;
typedef int (*FuncPtr)(int, int); // 函数指针别名
// using 定义别名（C++11+，支持模板）
using IntVec = std::vector<int>;
template <typename T>
using Ptr = T*; // 模板别名（typedef 无法实现）
Ptr<int> p = new int(10); // 等价于 int* p

template <typename T> // 等价于 template <class T>
class MyClass {
    typename T::SubType* ptr; // 声明 T::SubType 是类型（否则编译器视为成员变量）
};

bool flag = true;
char c = 'a';
int x = 10;
long long num = 1e18;
unsigned int cnt = 0;
wchar_t wstr[] = L"中文"; // 宽字符
char8_t u8str[] = u8"UTF-8"; // C++20 新增

class Base {
public:
    virtual void run() { cout << "Base run"; } // 虚函数（可被重写）
    virtual ~Base() { cout << "Base 析构"; }   // 虚析构（确保派生类析构被调用）
};
class Derived : public Base {
public:
    void run() override { cout << "Derived run"; } // 重写虚函数
    ~Derived() override { cout << "Derived 析构"; }
};
Base* obj = new Derived();
obj->run(); // 输出 "Derived run"（多态：运行时绑定）
delete obj; // 先调用 Derived 析构，再 Base 析构（无内存泄漏）

class Base {
public:
    virtual void func(int x) {}
};
class Derived : public Base {
public:
    void func(int x) override {} // 正确：重写 Base::func
    // void func(double x) override {} // 错误：参数类型不匹配（编译器报错）
};

class FinalClass final {}; // 禁止被继承
// class Sub : public FinalClass {}; // 错误
class Base {
public:
    virtual void stop() final {} // 禁止重写
};
class Derived : public Base {
    // void stop() override {} // 错误：stop 是 final
};

class Point {
public:
    explicit Point(int x) : x(x) {} // 禁止隐式转换
private:
    int x;
};
Point p1(10); // 正确：显式构造
// Point p2 = 10; // 错误：explicit 禁止 int→Point 的隐式转换

void func() noexcept { // 声明不抛异常
    // 若函数内抛出异常，会调用 std::terminate()
}
void func2() noexcept(false) { // 声明可能抛异常
    throw std::runtime_error("error");
}

constexpr int MAX = 100; // 编译期常量
constexpr int add(int x, int y) { return x + y; }
constexpr int sum = add(3, 5); // 编译期计算，sum=8