// 1. 全局/命名空間：僅當(dāng)前文件可見(jiàn)（避免跨文件重定義）
static int global_static = 10; // 其他文件無(wú)法通過(guò) extern 訪問(wèn)
// 2. 局部變量：生命周期延長(zhǎng)至程序結(jié)束（僅初始化1次）
void counter() {
    static int cnt = 0; 
    cnt++; 
    cout << cnt << " "; // 調(diào)用3次輸出：1 2 3
}
// 3. 類成員：屬于類（所有對(duì)象共享），需類外初始化
class Car {
public:
    static int total; // 聲明
    static void printTotal() { cout << total << endl; } // 無(wú) this 指針
};
int Car::total = 0; // 必須類外初始化（全局作用域）

// 1. 修飾變量：值不可改
const int MAX = 100; 
// MAX = 200; // 錯(cuò)誤：const 變量禁止寫入
// 2. 修飾指針（兩種場(chǎng)景）
const int* p1;    // 指針指向的內(nèi)容不可改（*p1 = 5 錯(cuò)誤）
int* const p2 = &MAX; // 指針本身不可改（p2 = &x 錯(cuò)誤）
const int* const p3; // 指針和內(nèi)容均不可改
// 3. 修飾成員函數(shù)：保證不修改非 static 成員（this 變?yōu)?const T*）
class A {
    int x = 5;
public:
    void print() const { 
        // x = 10; // 錯(cuò)誤：const 函數(shù)禁止修改成員
        cout << x << endl; 
    }
};
// 4. 修飾函數(shù)參數(shù)：防止函數(shù)內(nèi)部修改實(shí)參
void func(const string& s) { 
    // s = "new"; // 錯(cuò)誤：禁止修改參數(shù)
}

volatile int flag = 0; // 可能被其他線程/硬件修改
while (flag == 0) { 
    // 循環(huán)等待：每次從內(nèi)存讀 flag（而非寄存器緩存）
}

class Cache {
private:
    mutable int hit_count = 0; // 可在 const 函數(shù)中修改
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 聲明（無(wú)需初始化）
// 2. 調(diào)用 C 語(yǔ)言函數(shù)（避免 C++ 名稱修飾）
extern "C" {
    #include "c_library.h" // C 頭文件（如 printf）
}

#include <thread>
thread_local int thread_id = 0; // 每個(gè)線程有獨(dú)立的 thread_id
void worker(int id) {
    thread_id = id; 
    cout << "Thread " << thread_id << endl; // 每個(gè)線程輸出自己的 id
}
int main() {
    thread t1(worker, 1);
    thread t2(worker, 2);
    t1.join(); t2.join(); // 輸出：Thread 1 \n Thread 2
}

class A { 
    int x; // 默認(rèn) private（僅類內(nèi)訪問(wèn)）
};
struct B { 
    int y; // 默認(rèn) public（外部可直接訪問(wèn)）
};
// 繼承權(quán)限區(qū)別
class C : A { ... }; // 繼承默認(rèn) private（A 的 public 成員變?yōu)?C 的 private）
struct D : B { ... }; // 繼承默認(rèn) public（B 的 public 成員仍為 D 的 public）

// 傳統(tǒng) enum：作用域全局，可隱式轉(zhuǎn)換為 int（易沖突）
enum Color { RED, GREEN, BLUE };
Color c = RED;
int x = RED; // 隱式轉(zhuǎn)換（不推薦）
// enum class（強(qiáng)類型）：作用域受限，無(wú)隱式轉(zhuǎn)換（推薦）
enum class Direction { LEFT, RIGHT };
Direction d = Direction::LEFT; // 必須用 :: 訪問(wèn)
// int y = Direction::LEFT; // 錯(cuò)誤：無(wú)隱式轉(zhuǎn)換

// typedef 定義別名
typedef std::vector<int> IntVec;
typedef int (*FuncPtr)(int, int); // 函數(shù)指針別名
// using 定義別名（C++11+，支持模板）
using IntVec = std::vector<int>;
template <typename T>
using Ptr = T*; // 模板別名（typedef 無(wú)法實(shí)現(xiàn)）
Ptr<int> p = new int(10); // 等價(jià)于 int* p

template <typename T> // 等價(jià)于 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"; } // 虛函數(shù)（可被重寫）
    virtual ~Base() { cout << "Base 析構(gòu)"; }   // 虛析構(gòu)（確保派生類析構(gòu)被調(diào)用）
};
class Derived : public Base {
public:
    void run() override { cout << "Derived run"; } // 重寫虛函數(shù)
    ~Derived() override { cout << "Derived 析構(gòu)"; }
};
Base* obj = new Derived();
obj->run(); // 輸出 "Derived run"（多態(tài)：運(yùn)行時(shí)綁定）
delete obj; // 先調(diào)用 Derived 析構(gòu)，再 Base 析構(gòu)（無(wú)內(nèi)存泄漏）

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 {} // 錯(cuò)誤：參數(shù)類型不匹配（編譯器報(bào)錯(cuò)）
};

class FinalClass final {}; // 禁止被繼承
// class Sub : public FinalClass {}; // 錯(cuò)誤
class Base {
public:
    virtual void stop() final {} // 禁止重寫
};
class Derived : public Base {
    // void stop() override {} // 錯(cuò)誤：stop 是 final
};

class Point {
public:
    explicit Point(int x) : x(x) {} // 禁止隱式轉(zhuǎn)換
private:
    int x;
};
Point p1(10); // 正確：顯式構(gòu)造
// Point p2 = 10; // 錯(cuò)誤：explicit 禁止 int→Point 的隱式轉(zhuǎn)換

void func() noexcept { // 聲明不拋異常
    // 若函數(shù)內(nèi)拋出異常，會(huì)調(diào)用 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); // 編譯期計(jì)算，sum=8