1. C++ 基础（I/O、引用、函数、const、static、类型）¶

int n;
cin >> n;              // 从输入流取一个数，放进 n
cout << "n = " << n << endl;   // 把 "n = " 和 n 塞进输出流

int n;
cin >> n;                       // 先读个数
vector<int> v(n);               // 开一个长度 n 的数组
for (int i = 0; i < n; i++) {
    cin >> v[i];                // 逐个读入
}
for (int i = 0; i < n; i++) {
    cout << v[i] << " ";        // 逐个打印
}
cout << endl;

int value = 10;                 // 全局的 value
namespace ThirdParty {
    int value = 20;             // 第三方盒子里的 value
}

int main() {
    cout << ThirdParty::value << endl;   // 20  ← 指定从 ThirdParty 盒子取
    cout << value << endl;               // 10  ← 没指定，取全局的
}

int x = 100;
int& y = x;     // y 是 x 的别名（外号）。注意 & 写在类型后面
y = 200;        // 改 y 就是改 x
cout << x;      // 200  ← x 真的被改了

int& r = 1;     // ❌ 错误！1 是右值（临时的），没地址，普通引用绑不上

void byValue(int a)   { a = 99; }   // 值传递：a 是副本，改它不影响外面
void byPointer(int* a){ *a = 99; }  // 指针传递：传地址，能改外面
void byRef(int& a)    { a = 99; }   // 引用传递：传别名，能改外面

void func(const vector<int>& v)  // 既省了拷贝，又保证不被改

void printSum(int a, int b = 10) { cout << a + b << endl; }

printSum(5);      // 输出 15  ← b 用默认值 10
printSum(5, 5);   // 输出 10  ← b 用传进来的 5

void print(int i)            { cout << "Integer\n"; }
void print(double f)         { cout << "Double\n"; }
void print(int i, double f)  { cout << "Int & Double\n"; }

inline int getMax(int a, int b) { return a > b ? a : b; }

vector<int> nums = {1, 4, 3, 5, 2, 6};
sort(nums.begin(), nums.end(), [](int a, int b){ return a > b; });
//                              ↑ 这个 lambda 就是排序规则：a 排在 b 前当 a > b → 降序

int x = 1;
auto f = [x]() { cout << x << endl; };   // 按值：拍了张快照
auto g = [&x]() { x++; };                // 按引用：用的是本体
g();
cout << x << endl;   // 2  ← g 通过引用把 x 改了

const int MAX = 100;   // MAX 定死，不能再改。C++ 推荐用 const 而不是 #define 宏

int a = 1, c = 4;

const int* p1 = &a;   // const 在 * 左边 → 不能改"指向的内容"，但能改 p1 指向谁
//  *p1 = 5;   ❌ 错（改内容不行）
    p1 = &c;   // ✅ 对（改指向可以）

int* const p2 = &a;   // const 在 * 右边 → p2 本身定死，但能改内容
    *p2 = 5;   // ✅ 对（改内容可以）
//  p2 = &c;   ❌ 错（改指向不行）

const int* const p3 = &a;   // 两边都 const → 内容和指向都不能改

void printMsg(const string& msg) { cout << msg; }  // 既不拷贝，又防止改

class User {
    string name;
public:
    string getName() const {   // const 加在括号后面：承诺这个函数不改任何成员
        // name = "x";   ❌ 编译报错
        return name;
    }
};

void f() {
    static int count = 0;   // 只在第一次进函数时初始化
    count++;
    cout << count << " ";
}
f(); f(); f();   // 输出 1 2 3  ← count 没被销毁，一直累加

class Player {
public:
    static int total;        // 所有 Player 对象共享这一个 total
    Player() { total++; }
};
int Player::total = 0;       // ⚠️ 必须在类外定义初始化（程序填空常考这一行）

Player a, b, c;
cout << Player::total;       // 3  ← 可以直接用类名访问，不需要对象

class MathUtils {
public:
    static int add(int a, int b) { return a + b; }   // 静态成员函数
};
int sum = MathUtils::add(5, 3);   // 不用建对象，直接类名调用

union Data { int i; float f; };   // i 和 f 共用一块内存，同时只能用一个
Data d;
d.i = 10;          cout << d.i;    // 10
d.f = 220.5;       cout << d.f;    // 220.5（此时 i 的值已被覆盖，读 i 是未定义行为）

// 传统枚举：成员名"全局可见"，容易撞名
enum Color { RED, GREEN, BLUE };   // RED=0, GREEN=1, BLUE=2
Color c = RED;

// 强类型枚举 enum class（C++11，现代首选）
enum class Status { OK = 200, NOT_FOUND = 404 };
Status s = Status::OK;             // 必须带作用域 Status::