// 一眼看出"现代 C++"和老 C++ 的差别：
// 无裸 new/delete、无手写循环、类型自动推导
#include <algorithm>
#include <memory>
#include <vector>

auto widget = std::make_unique<Widget>();   // RAII 管生命周期

std::vector<int> v{3, 1, 4, 1, 5};
std::ranges::sort(v);                        // C++20 ranges

auto even = std::ranges::count_if(v,
    [](int x) { return x % 2 == 0; });     // lambda

// hello.cpp —— 第一个完整、可直接编译运行的程序
#include <iostream>

int main() {
    std::cout << "Hello, C++!" << "\n";
    return 0;
}

// ---- 在终端里执行这两条 ----
// 1) 编译：产出可执行文件 hello
//    g++ -std=c++20 -Wall -Wextra hello.cpp -o hello
// 2) 运行
//    ./hello          （Windows: hello.exe）
// 输出：Hello, C++!

// ---- 若用 Visual Studio 的 cl 编译器，等价命令是 ----
//    cl /EHsc /std:c++17 /W4 hello.cpp
// 本页后续一律用 g++ 的写法。

#include <iostream>   // ① 引入输出功能所在的头文件

int main() {            // ② 程序入口，花括号包住函数体
    std::cout << "Hello, C++!" << "\n";   // ③ 一条语句，以分号结尾
    return 0;         // ④ 返回 0 = 正常退出
}

// 缩进和换行都不影响语义——下面这行与上面那个 main 完全等价
// （只是给人读的可读性没了，别真这么写；两者不能同时存在于一个程序）
// int main(){std::cout<<"Hello, C++!"<<"\n";return 0;}

// ① 编译期：漏了分号
int x = 1
int y = 2;
// error: expected ',' or ';' before 'int'   ← 报在第 2 行，错在第 1 行行尾

// ① 编译期：忘了 #include <vector> 就用 std::vector
std::vector<int> v;
// error: 'vector' is not a member of 'std'
// 提示：漏 include 不一定报错——有些头文件会顺带引入别的头，
// 所以"能编过"不代表你 include 全了，用到什么就显式 include 什么

// ② 链接期：main 拼错了
int mian() { return 0; }
// undefined reference to 'main'   ← 没有行号 = 链接期

// ③ 运行期：编译通过，运行才崩
#include <vector>
int main() {
    std::vector<int> v = {1, 2, 3};
    return v[10];          // 越界：编译零报错，运行时未定义行为
}
// g++ -g -fsanitize=address 编译后运行会指出越界位置。
// 想让 vector 的越界检查更可靠，可再加 -D_GLIBCXX_ASSERTIONS；
// 或者干脆用 v.at(10)，它会抛异常而不是默默越界。

#include <iostream>   // cout / cin 来自这里
#include <string>

// 把第一行 Hello World 逐块解码：
std::cout << "Hi" << std::endl;
//   ↑ std 里的 cout   ↑ 流插入运算符   ↑ std 里的 endl
// = 「取标准库的 cout，插入 "Hi"，再插入换行并刷新」

// :: 的四种用法
std::string s;              // 命名空间 :: 名字
Color c = Color::Red;       // 枚举 :: 成员
int n = app::version;       // 自定义命名空间 :: 名字
::malloc(8);                // :: 名字 → 全局作用域

// 同一个 << —— 看左边是谁，决定它是哪副面孔
std::cout << 16;             // 左边是流 → 输出 16
int x = 1 << 4;            // 左边是整数 → 位移，得 16

// 少写 std:: 的两种方式
using std::cout;            // 只引入一个名字（推荐）
using namespace std;        // 引入全部（.cpp 里可，头文件中忌）

#include <string>

int x = 42;
double pi = 3.14159;   // 浮点字面量默认 double，不是 float
bool flag = true;
int oops;               // ⚠️ 未初始化：值是垃圾，读它是 UB

// auto 推导（C++11）——照抄右边的类型，但丢掉 const 和引用
auto i = 10;                // int
auto s = std::string("hi"); // std::string
const int& r = x;
auto a = r;                 // int！const 和 & 都被丢了 → 是份拷贝
const auto& b = r;         // const int&：要保留就自己写回来

// auto + {} 的怪癖
auto one{1};         // int（C++17 起）
auto list = {1, 2};  // initializer_list<int>，多半不是你想要的

// const 与 constexpr
const int doubled = x * 2; // 只读，但值运行期才定
constexpr int SIZE = 256;  // 保证编译期算出（可作数组长度）

// 三种写法
int a = 42;      // 拷贝初始化
int b(42);       // 直接初始化
int c{42};       // 列表初始化（推荐）

// {} 禁止窄化，把隐蔽 bug 变编译错误
int x = 3.14;    // 静默截断成 3（危险）
// int y{3.14};  // ❌ 编译报错：不允许 double→int 窄化

// most vexing parse：这不是构造对象，是声明函数！
Widget w1();       // ⚠️ 声明「返回 Widget 的函数 w1」
Widget w2;         // ✅ 默认构造
Widget w3{};       // ✅ 默认构造（更明确）

// () 与 {} 对容器含义不同
std::vector<int> v1(10, 2);  // 10 个 2
std::vector<int> v2{10, 2};  // 两个元素：10, 2

#include <iostream>
#include <map>
#include <string>
#include <vector>

// 范围 for 循环（C++11）—— 遍历容器的首选方式
std::vector<int> nums = {1, 2, 3, 4, 5};
for (const auto& n : nums) {
    std::cout << n << " ";
}

// switch：整数 / 枚举分支；注意 break，多标签可共用，穿透用 [[fallthrough]]
char grade = 'B';
switch (grade) {
    case 'A': std::cout << "优秀"; break;
    case 'B':
    case 'C': std::cout << "及格"; break;   // B、C 共用一段
    default:  std::cout << "其他";
}

// 三目 ?: 是表达式，有返回值——可直接用于初始化
const char* tag = (grade == 'A') ? "top" : "normal";

// if 带初始化语句（C++17）—— map 等容器见 05 章
std::map<std::string, int> m = {{"key", 1}};
if (auto it = m.find("key"); it != m.end()) {
    std::cout << it->second;  // it 仅在 if 块内可见
}

// 结构化绑定（C++17）
std::map<std::string, int> scores = {{"Alice", 95}};
for (const auto& [name, score] : scores) {
    std::cout << name << ": " << score;
}

// 重载：同名不同参，编译器按实参挑
int    add(int a, int b)       { return a + b; }
double add(double a, double b) { return a + b; }
add(1, 2);        // 精确匹配 int 版
add(1.0, 2.0);    // 精确匹配 double 版
// add(1, 2.0);   // ❌ ambiguous：int→double 与 double→int 打平

// NULL 的教训：整数 0 优先匹配 int 版
void f(int);
void f(char*);
f(NULL);           // g++/clang 报 ambiguous，别家可能选 f(int)——都拿不到指针版；请用 f(nullptr)

// 默认参数：从右往左，声明处写一次
void greet(std::string name = "World");
greet();           // Hello, World!
greet("C++");      // Hello, C++!

// inline：允许定义进头文件而不违反 ODR
inline int square(int x) { return x * x; }  // 放 .h 多处包含不冲突

#include <string>
#include <string_view>

std::string s = "Hello";
s += ", C++!";           // 拼接
s.size();                // 长度：11
s.find("C++");           // 查找：7
s.substr(0, 5);         // 子串："Hello"

// string_view：零拷贝的只读视图（C++17）
void print(std::string_view sv) {
    std::cout << sv;  // 不会拷贝字符串内容
}
print("literal");   // 字面量直接传入，零开销
print(s);            // string 隐式转换

#include <iostream>
#include <print>       // C++23：std::print / println
#include <limits>
#include <string>

// 惯用法：读取失败就清理流、重新提示，直到读到合法值
int age;
std::cout << "请输入年龄: ";
while (!(std::cin >> age)) {           // 读失败 → 流转为 false
    std::cin.clear();                    // 1. 清除失败状态位
    std::cin.ignore(                     // 2. 丢弃这一整行脏输入
        std::numeric_limits<std::streamsize>::max(), '\n');
    std::cout << "无效输入，请输入数字: ";
}

// >> 之后接 getline：先清掉流里残留的换行符
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::string name;
std::getline(std::cin, name);          // 读一整行，可含空格

// 输出两种写法：经典 cout vs 现代 println（本指南 05 章起默认后者）
std::cout << name << " 是 " << age << " 岁\n";
std::println("{} 是 {} 岁", name, age);  // 等价、更短、类型安全

// 竞赛加速两件套（之后不可再混用 printf/scanf）
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);

#include <fstream>
#include <sstream>
#include <string>

std::ifstream fin("scores.txt");  // 构造即打开
if (!fin) {                             // 必须先判断是否打开成功
    std::cerr << "无法打开文件\n";
    return 1;
}

// 逐行读 + istringstream 解析：健壮读入的标准姿势
std::string line;
while (std::getline(fin, line)) {
    std::istringstream iss(line);       // 把这一行当成输入流
    std::string name;
    int score;
    if (iss >> name >> score) {    // 解析失败只影响这一行
        std::cout << name << ": " << score << "\n";
    }
}                                        // fin 离开作用域自动关闭（RAII）

// 写文件：默认截断原内容，ios::app 表示追加
std::ofstream fout("app.log", std::ios::app);
fout << "new entry\n";

// ostringstream：在内存里拼接
std::ostringstream oss;
oss << "(" << 3 << ", " << 4 << ")";
std::string point = oss.str();      // "(3, 4)"

// 二进制：加 ios::binary，用 write()/read() 按字节搬运
int vals[] = {1, 2, 3};
std::ofstream bout("data.bin", std::ios::binary);
bout.write(reinterpret_cast<const char*>(vals), sizeof(vals));

#include <string>
#include <algorithm>

// UTF-8 变长：一个「字符」占 1~4 字节
std::string s = "A你🎉";         // A=1 字节  你=3 字节  🎉=4 字节
s.size();                       // 8，不是 3！返回的是字节数

// 下标 / substr 都按「字节」走，不按「字符」
(unsigned char)s[0];            // 0x41 = 'A'（正好一个完整字符）
(unsigned char)s[1];            // 0xE4 = '你'的第 1 字节，单独看是乱码
s.substr(0, 2);                 // "A" + 半个'你' → 末尾一个乱码字节

// 正确地数「字符数」：跳过续接字节(10xxxxxx)
std::size_t n = 0;
for (unsigned char c : s)
    if ((c & 0xC0) != 0x80) ++n;  // n = 3

// 要按字符随机访问，转成定长码点的 u32string
std::u32string u32 = U"A你🎉";       // u32.size()==3，u32[1]==U'你'

// 四种字符类型：只有 char32_t「一个 = 一个码点」
char     a  = 'A';              // 1 字节
char8_t  c8 = u8'A';            // C++20，UTF-8 码元，不与 char 互通
char16_t h  = u'你';             // UTF-16 码元
char32_t p  = U'你';             // 一个码点，定长 4 字节
wchar_t  w  = L'A';             // 平台相关：Win 16 位 / Linux 32 位

// string ⇄ u8string：同是 UTF-8 字节，reinterpret_cast 逐字节搬
std::u8string u8s = u8"你好";
std::string s2(reinterpret_cast<const char*>(u8s.data()), u8s.size());

// 跨编码(UTF-8⇄16⇄32)：<codecvt> 已于 C++17 弃用，改用 ICU/utf8cpp；
// Windows 上用 MultiByteToWideChar / WideCharToMultiByte：
// —— UTF-8(string) → UTF-16(wstring)，喂给 ...W 版 API ——
// 需 <windows.h>；反向转换用 WideCharToMultiByte
std::wstring to_utf16(const std::string& u8) {
    int len = MultiByteToWideChar(CP_UTF8, 0, u8.data(), (int)u8.size(), nullptr, 0);
    std::wstring w(len, L'\0');
    MultiByteToWideChar(CP_UTF8, 0, u8.data(), (int)u8.size(), w.data(), len);
    return w;
}

// 多文件项目的最小形态：声明进头文件，实现进 .cpp
// ---- math.h ----
#pragma once
int add(int a, int b);        // 声明：告诉编译器"有这么个函数"

// ---- math.cpp ----
#include "math.h"
int add(int a, int b) { return a + b; }   // 定义：全程序仅此一份

// ---- main.cpp ----
#include <iostream>
#include "math.h"
int main() {
    std::cout << add(1, 2) << "\n";
}

// 分步编译，看清两个阶段：
// g++ -std=c++20 -Wall -Wextra -c math.cpp   → math.o（只编译）
// g++ -std=c++20 -Wall -Wextra -c main.cpp   → main.o
// g++ math.o main.o -o app                   → 链接成可执行文件
// 若漏掉 math.o：undefined reference to 'add(int, int)' ← 链接期错误

#include <cstdint>

int32_t a = 2000000000;
int32_t b = a + a;        // 有符号溢出 = UB！不是回绕

// 有无符号混用：-1 变成巨大正数
int s = -1;
unsigned u = 1;
bool bad = (s < u);          // false！s 被转成 4294967295

// 遍历用 size_t，别拿 int 和 .size() 比
std::vector<int> v(10);
for (std::size_t i = 0; i < v.size(); ++i) { }  // 类型一致

unsigned a = 0b1100, b = 0b1010;
a & b;   // 1000 —— 都为 1 才留
a | b;   // 1110 —— 有一个 1 就留
a ^ b;   // 0110 —— 不同才为 1
~a;      // 按位取反（逐比特翻转）

// 标志位：一个整数装多个开关
constexpr unsigned READ = 1, WRITE = 2, EXEC = 4;
unsigned perm = READ | WRITE;      // 置位：可读可写
bool canWrite = perm & WRITE;       // 查位：非 0 即有
perm &= ~WRITE;                     // 清位：去掉写权限

// 掩码取字段 & 移位
unsigned rgb = 0x3399FF;
unsigned g = (rgb >> 8) & 0xFF;    // 取绿色分量 = 0x99
int n = 7;
bool odd = n & 1;                  // 判奇偶：最低位是 1 即为奇数

// 命名空间：给名字分组，避免冲突
namespace app {
    int version = 1;
}
using app::version;          // 引入单个名字
using namespace std;        // 引入整个命名空间（头文件中慎用）

// enum class：强类型枚举（不隐式转 int、作用域隔离）
enum class Color { Red, Green, Blue };
Color c = Color::Red;         // 必须带作用域前缀
int n = static_cast<int>(c);   // 需显式转换，不会隐式退化

// 四种命名转换，各司其职
double d = static_cast<double>(n);         // 相关类型间的安全转换
Derived* dp = dynamic_cast<Derived*>(basePtr);  // 多态向下转型：失败得 nullptr
int& nc = const_cast<int&>(constRef);      // 去除 const（仅在确无副作用时）
auto bits = reinterpret_cast<std::uintptr_t>(dp); // 底层位模式重解释（危险）

int x = 42;

// 指针
int* p = &x;       // p 指向 x
*p = 100;          // 通过指针修改 x 的值
p = nullptr;       // 空指针（C++11）

// 引用
int& r = x;        // r 是 x 的别名
r = 200;           // 等价于 x = 200

// 函数参数传递：引用避免拷贝
void process(const std::string& s) {
    // s 是原字符串的只读引用，零拷贝
}

int a = 1, b = 2;

// ① 指向常量的指针：数据只读，指针可重指
const int* p1 = &a;
// *p1 = 9;   ❌ 不能改数据
p1 = &b;         // ✅ 可以重新指向

// ② 常量指针：数据可改，指针锁定
int* const p2 = &a;
*p2 = 9;         // ✅ 可以改数据（a 变 9）
// p2 = &b;   ❌ 不能重指

// ③ 两者都锁死
const int* const p3 = &a;

// const 正确性：只读接口标 const，才能接收 const 数据
size_t strLen(const char* s) {   // 承诺不改 s 指向的内容
    size_t n = 0;
    while (s[n] != '\0') ++n;
    return n;
}

int a[5] = {10, 20, 30, 40, 50};

int* p = a;          // 数组名退化为 &a[0]
*(p + 2);            // == a[2] == 30，地址加了 2*sizeof(int)
p[3];                // == *(p + 3) == 40，下标就是指针运算
++p;                 // 现在 p 指向 a[1]

// 用指针遍历（half-open 区间 [begin, end)）
for (int* it = a; it != a + 5; ++it)
    std::cout << *it << ' ';

sizeof(a);           // 20：整个数组（5 * 4 字节）

void sum(int* arr, size_t n) {
    sizeof(arr);      // ⚠️ 只有 8（x86-64 Linux）：arr 已退化成指针
}

#include <span>

// 一个函数吃遍所有连续容器，且不丢长度
int sum(std::span<const int> xs) {
    int s = 0;
    for (int v : xs) s += v;   // 自带 begin/end 与 size
    return s;
}

int carr[] = {1, 2, 3};
std::vector<int> vec = {4, 5, 6};
sum(carr);              // C 数组 → span，长度自动推出 3
sum(vec);               // vector 也行，零拷贝

// 可写视图 + 切片
std::span<int> sp = vec;
sp[0] = 99;             // 直接改到 vec
auto tail = sp.subspan(1);  // 从第 1 个到末尾的子视图

// ① 输出参数：函数替调用方分配并回填指针
void makeBuf(int** out, int n) {
    *out = new int[n]{};   // 写进 *out，调用方的指针被改
}
int* buf = nullptr;
makeBuf(&buf, 8);        // 传 buf 的地址（int**）

// ② 指针数组 = char**：命令行参数就是这个形状
int main(int argc, char** argv) {
    for (int i = 0; i < argc; ++i)
        std::cout << argv[i];  // argv[i] 是 char*，一个字符串
}

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

// 声明一个函数指针并赋值（& 可省）
int (*op)(int, int) = add;
op(3, 4);          // 7，等价于 (*op)(3, 4)
op = mul;              // 换一个行为

// 把行为当参数：回调
int apply(int x, int y, int (*f)(int, int)) {
    return f(x, y);
}
apply(6, 7, mul);  // 42

// 现代写法：std::function 能装下带捕获的 lambda
int base = 100;
std::function<int(int)> g = [base](int x) { return x + base; };
g(5);              // 105（裸函数指针做不到）

class Vec2 {
public:
    double x, y;

    // 构造函数 + 初始化列表
    Vec2(double x, double y) : x(x), y(y) {}

    // 成员函数
    double length() const {
        return std::sqrt(x*x + y*y);
    }

    // 运算符重载（机制详见本章「运算符重载」卡）
    Vec2 operator+(const Vec2& other) const {
        return {x + other.x, y + other.y};
    }
};

Vec2 a(3, 4);
a.length();  // 5.0

class Builder {
    std::string text_;
public:
    // 参数名与成员同名 → 用 this-> 消歧
    Builder& setText(const std::string& text) {
        this->text_ = text;   // this-> 点明左边是成员，不是参数
        return *this;      // 返回自身引用 → 可链式
    }
    Builder& append(std::string_view s) {
        text_ += s;             // 等价于 this->text_ += s
        return *this;
    }
    const std::string& str() const { return text_; }
    // 此处 this 的类型是 const Builder*，故改不了成员
};

// 链式调用（fluent interface）
Builder b;
b.setText("Hello").append(", C++").append("!");
b.str();   // "Hello, C++!"

class Buffer {
    int* data_;
    size_t size_;
public:
    // 构造
    Buffer(size_t n) : data_(new int[n]), size_(n) {}

    // 析构
    ~Buffer() { delete[] data_; }

    // 拷贝构造（深拷贝）
    Buffer(const Buffer& other)
        : data_(new int[other.size_]), size_(other.size_) {
        std::copy(other.data_, other.data_ + size_, data_);
    }

    // 移动构造（窃取资源）
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }

    // 拷贝赋值 & 移动赋值类似...
};

struct Vec2 {
    double x, y;

    // ① 成员形式：左操作数是本类
    Vec2 operator+(const Vec2& o) const { return {x + o.x, y + o.y}; }

    // ② C++20：一行生成全部比较运算符
    auto operator<=>(const Vec2&) const = default;
};

// ③ 自由函数：左操作数是 ostream，只能写在类外
std::ostream& operator<<(std::ostream& os, const Vec2& v) {
    return os << '(' << v.x << ", " << v.y << ')';  // 返回流以支持链式
}

Vec2 a{1, 2}, b{3, 4};
std::cout << a + b;   // (4, 6) —— operator+ 和 operator<< 一起起作用

class Shape {
public:
    virtual double area() const = 0;  // 纯虚函数 → 抽象类
    virtual ~Shape() = default;       // ⚠️ 虚析构必须有！
};

class Circle : public Shape {
    double r_;
public:
    Circle(double r) : r_(r) {}
    double area() const override {    // override 防止拼错
        return 3.14159 * r_ * r_;
    }
};

// 多态：用基类的「引用」或「指针」指向派生类对象
Circle c(5.0);
Shape& s = c;          // 基类引用绑定派生对象
s.area();             // 调用的是 Circle::area()，返回 78.5

Shape* p = &c;         // 基类指针同理
p->area();            // 78.5

// 注意：多态必须经由引用或指针。这里 Shape 含纯虚函数（抽象类），
// 连 Shape s2 = c; 都编译不过；基类若是非抽象的，按值赋过去则会
// 静默「切片」——派生部分被截断、多态失效。见本章进阶段的 vtable 卡。

// 实际工程里这类对象多半建在堆上、由智能指针持有，写法是：
//   std::unique_ptr<Shape> sp = std::make_unique<Circle>(5.0);
// 现在把它当成「会自动释放的 Shape*」即可，08 章专门讲。

struct Base {
    virtual void speak() const { std::cout << "base"; }
    virtual ~Base() = default;   // 无它则 delete 派生对象泄漏
};
struct Derived final : Base {   // final：不可再被继承
    void speak() const override { std::cout << "derived"; }
};

// ✅ 指针 / 引用 → 动态分派
std::unique_ptr<Base> p = std::make_unique<Derived>();
p->speak();          // "derived"，查 vtable

// ❌ 按值 → 切片，多态没了
Derived d;
Base sliced = d;        // 派生部分被截断
sliced.speak();     // "base"！vptr 已复位

// 手写一次移动构造，看清"偷"的两个步骤
class Buffer {
    int* data_;
    size_t n_;
public:
    Buffer(Buffer&& other) noexcept           // noexcept：vector 扩容才敢用它
        : data_(other.data_), n_(other.n_) {  // ① 接管指针
        other.data_ = nullptr;                // ② 源置空，防双重释放
        other.n_ = 0;
    }
    ~Buffer() { delete[] data_; }             // 置空后源的析构安全无害
};

std::string a = "Hello";
std::string b = std::move(a);   // a 的堆内存被 b 接管
// a 此后"有效但未指定"：可赋新值，别读旧值

std::vector<std::string> vec;
vec.push_back(std::move(b));    // 移动进容器，零拷贝

std::vector<int> makeData() {
    std::vector<int> v = {1, 2, 3};
    return v;                // ✅ 直接 return：NRVO 连移动都省掉
    // return std::move(v);  // ❌ 反而抑制 NRVO，强制走移动
}

#include <vector>

std::vector<int> v = {1, 2, 3};
v.push_back(4);         // 尾部添加
v.emplace_back(5);      // 原地构造，避免拷贝
v.size();                // 5
v[0];                    // 1（不检查越界）
v.at(0);                 // 1（越界抛异常）
v.pop_back();             // 移除末尾

// 预分配容量避免频繁扩容
std::vector<int> big;
big.reserve(10000);     // 预留空间，不改变 size

// 边遍历边删：必须用 erase 的返回值前进
for (auto it = v.begin(); it != v.end(); ) {
    if (*it < 0) it = v.erase(it);  // erase 返回下一个有效迭代器
    else ++it;
}

// list 不支持 std::sort（非随机访问）→ 用成员函数
std::list<int> lst = {3, 1, 2};
lst.sort();               // ✅   std::sort(lst.begin()...) ❌

// 预留容量，避免遍历中扩容令迭代器悬垂
std::vector<int> v2;
v2.reserve(1000);

#include <unordered_map>

std::unordered_map<std::string, int> scores;
scores["Alice"] = 95;
scores["Bob"] = 87;

// 安全查找（不会意外插入）
if (auto it = scores.find("Alice"); it != scores.end()) {
    std::print("{}", it->second);  // 95
}

// C++17: try_emplace 避免重复构造
scores.try_emplace("Charlie", 92);

// C++17: insert_or_assign 覆盖式插入
scores.insert_or_assign("Alice", 99);

// 一个 key 对应多个值：multimap / multiset（允许重复键，无 operator[]）
std::multimap<std::string, int> mm;
mm.emplace("Alice", 95);
mm.emplace("Alice", 88);          // 同键再存一个，不覆盖
auto [lo, hi] = mm.equal_range("Alice"); // 取该键的全部值 [lo, hi)
for (auto it = lo; it != hi; ++it) std::print("{} ", it->second); // 95 88

struct Point { int x, y; };

// 有序容器：给个严格弱序比较器
auto cmp = [](Point a, Point b){ return a.x < b.x; };
std::set<Point, decltype(cmp)> s(cmp);

// unordered_map：哈希 functor + operator==
struct PointHash {
    std::size_t operator()(Point p) const {
        std::size_t h = std::hash<int>{}(p.x);
        h ^= std::hash<int>{}(p.y) + 0x9e3779b9 + (h << 6) + (h >> 2); // 混合，非裸异或
        return h;
    }
};
bool operator==(Point a, Point b){ return a.x==b.x && a.y==b.y; }
std::unordered_map<Point, int, PointHash> m;

#include <queue>
#include <stack>

std::stack<int> st;
st.push(1); st.top(); st.pop();   // LIFO

// 默认大顶堆：top() 最大
std::priority_queue<int> maxHeap;
maxHeap.push(3); maxHeap.push(1); maxHeap.push(4);
maxHeap.top();          // 4

// 小顶堆：传 greater
std::priority_queue<int, std::vector<int>, std::greater<>> minHeap;

#include <algorithm>
#include <vector>

std::vector<int> v = {5, 2, 8, 1, 9, 3};

// 排序
std::sort(v.begin(), v.end());              // 升序
std::sort(v.begin(), v.end(), std::greater<>()); // 降序

// Lambda 配合算法
auto it = std::find_if(v.begin(), v.end(),
    [](int x) { return x > 5; });

int sum = 0;
std::for_each(v.begin(), v.end(),
    [&sum](int x) { sum += x; }); // 按引用捕获 sum

// 常用算法速查
std::count_if(v.begin(), v.end(), [](int x){ return x%2==0; });
std::any_of(v.begin(), v.end(), [](int x){ return x>8; });
std::transform(v.begin(), v.end(), v.begin(),
    [](int x){ return x * 2; });

#include <optional>
#include <variant>
#include <any>
#include <tuple>

// optional：可能失败的查找
std::optional<std::string> findUser(int id) {
    if (id == 1) return "Alice";
    return std::nullopt;  // 没找到
}

if (auto user = findUser(1)) {
    std::print("{}", *user);  // "Alice"
}

// variant：类型安全的联合体
std::variant<int, std::string> val = 42;
val = "hello";  // 现在持有 string

std::visit([](auto& v) {
    std::print("{}", v);  // 自动匹配当前类型
}, val);

// any：持有任意类型，取值时必须知道确切类型
std::any a = 42;                 // 现在是 int
a = std::string("hi");           // 换成 string
std::string as = std::any_cast<std::string>(a); // 类型不符会抛 bad_any_cast

// tuple：打包多个值，用结构化绑定解包（C++17）
std::tuple<int, std::string> status() {
    return {200, "OK"};    // 直接列表初始化返回
}
auto [code, msg] = status();  // code=200, msg="OK"
std::println("{} {}", code, msg);

#include <regex>
#include <charconv>

// —— <regex> 正则 ——
std::string s = "订单 A-1024 已发货";
std::regex re(R"(([A-Z])-(\d+))");        // 原始字符串字面量免转义反斜杠
std::smatch m;
if (std::regex_search(s, m, re)) {         // 在串里搜；regex_match 要求整串匹配
    std::string whole = m[0];              // "A-1024"
    std::string id    = m[2];              // "1024"（捕获组 2）
}
std::string out = std::regex_replace(s, re, "[$2]");  // "订单 [1024] 已发货"

// 遍历所有匹配：sregex_iterator
for (std::sregex_iterator it(s.begin(), s.end(), re), end; it != end; ++it)
    std::println("{}", (*it)[0].str());

// —— <charconv> 快速转换（C++17）——
int n = 0;
const char* str = "42abc";
// 解析数字｜传 起址+止址+接收变量(+进制)｜返回 {ptr 停在首个未消费字符, ec 错误码}
auto [ptr, ec] = std::from_chars(str, str + 5, n);   // n=42，ptr 指向 'a'
if (ec == std::errc{}) { /* 成功 */ }

char buf[16];
// 格式化数字到缓冲｜传 起址+止址+值(+进制/精度)｜返回 {ptr 写入末尾, ec}
auto [p2, ec2] = std::to_chars(buf, buf + sizeof buf, 3.14);  // 写 "3.14"

// ——— 四个最高频任务的成品写法（表里查到名字后，照着抄）———

// ① 整个文件读进 string
std::ifstream fin("a.txt");
std::string text{std::istreambuf_iterator<char>(fin), {}};

// ② 按行读
for (std::string line; std::getline(fin, line); ) {
    // 用 line；注意 getline 会吃掉换行符，行尾可能还留 '\r'（Windows 文本）
}

// ③ vector 去重（先排序，再把重复项挪到末尾删掉）
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());

// ④ 统计词频，按出现次数从高到低
std::unordered_map<std::string, int> cnt;
for (const auto& w : words) ++cnt[w];      // 不存在的 key 自动值初始化为 0
std::vector<std::pair<std::string, int>> top(cnt.begin(), cnt.end());
std::ranges::sort(top, std::greater{}, &std::pair<std::string, int>::second);
//                       ↑ 比较器      ↑ 投影：拿 .second 去比，不用手写 lambda

// ══════ <vector> ── 动态数组：连续内存，拿不准就选它 ══════
std::vector<int> v{1,2,3};
// 尾部追加一个元素｜摊还 O(1)｜⚠ 触发扩容时，所有迭代器与引用全部失效
v.push_back(4);
// 在尾部就地构造，省一次拷贝/移动｜摊还 O(1)｜失效规则同 push_back
v.emplace_back(5);
// 预分配容量｜O(n)｜已知规模时先调用一次，可完全避免中途反复扩容搬数据
v.reserve(1000);
// 下标访问，不检查越界｜O(1)｜⚠ 越界是 UB——不报错，读到垃圾值或直接崩
v[i];
// 下标访问，检查越界｜O(1)｜越界抛 std::out_of_range
v.at(i);
// 删除指定位置的元素｜O(n)，后续元素整体前移｜被删位置及其之后的迭代器失效
v.erase(v.begin() + 1);
// 移除末尾元素｜O(1)｜⚠ 不返回被删的值，要用先 back() 取再 pop_back()；空容器上调用是 UB
v.pop_back();
// 元素个数 / 是否为空 / 清空 / 首元素 / 尾元素｜均 O(1)｜clear 只析构元素不还内存，要还用 shrink_to_fit
v.size();  v.empty();  v.clear();  v.front();  v.back();

// ══════ <array> ── 栈上定长数组：值语义，可拷贝、可比较、可 return ══════
// 定长数组，长度是类型的一部分｜元素在栈上，无堆分配｜与 C 数组的关键差别：不退化成指针
std::array<int,3> a{1,2,3};
// 元素个数｜O(1)｜编译期常量，可用在 constexpr 与模板参数里
a.size();
// 值初始化全部元素为 0｜⚠ 不写 {} 时内置类型元素是未初始化的垃圾值
std::array<int,3> z{};

// ══════ <deque> / <list> / <forward_list> ── 其余序列容器 ══════
// 双端队列：两端都能高效进出｜push_front / push_back 均摊还 O(1)｜内存分段不连续，随机访问慢于 vector
std::deque<int> dq;   dq.push_front(0);   dq.push_back(1);
// 双向链表：任意位置插入删除｜已持有迭代器时 O(1)｜无随机访问；插入永不使已有迭代器失效
std::list<int> ls;
// 把另一个链表的整段搬过来｜O(1)，链表独有｜只改指针，不拷贝也不移动元素
ls.splice(ls.begin(), other);
// 单向链表：每个节点少存一个指针｜内存极敏感时才值得用｜没有 size()、不能反向遍历
std::forward_list<int> fl;

// ══════ <span> / <bitset> ── 视图与位集 ══════
// C++20：借用一段连续内存的非拥有视图｜构造 O(1)｜⚠ 不延长生命周期，别比源容器活得久
std::span<int> sp{v};
// 定长位集合，替代手写位掩码｜长度编译期固定
std::bitset<8> bs{0b1010};
// 置位个数 / 测第 n 位｜count 按机器字数与位数成正比,test O(1)｜下标从最低位算起
bs.count();   bs.test(1);

// ══════ <map> / <set> ── 有序关联容器（红黑树），始终按 key 升序 ══════
std::map<std::string, int> m;
// 按 key 取值的引用并可赋值｜O(log n)｜⚠ key 不存在时会「顺手插入」一个默认值——只读时千万别用
m["k"] = 1;
// 按 key 取值，绝不插入｜O(log n)｜缺 key 抛 std::out_of_range
m.at("k");
// 判断 key 是否存在｜O(log n)｜C++20；老写法是 m.find("k") != m.end()
m.contains("k");
// key 不存在才插入｜O(log n)｜已存在则原样不动，且不白构造一个 value（优于 insert）
m.try_emplace("k", 1);
// 遍历全部键值对｜O(n)｜按 key 升序 —— 这正是有序容器存在的理由
for (const auto& [k, val] : m) {}
// 存在则覆盖，不存在则插入｜O(log n)｜C++17；与 operator[] 的区别是不要求 value 可默认构造
m.insert_or_assign("k", 2);
// 定位第一个 ≥ k 的元素｜O(log n)｜区间查询靠它，unordered_map 没有这个能力
m.lower_bound("k");
// 允许一个 key 存多个值｜没有 operator[]，只能 emplace / insert
std::multimap<std::string, int> mm;   mm.emplace("k", 1);   mm.emplace("k", 2);
// 取某个 key 的全部值区间 [lo, hi)｜O(log n)｜这是 multimap 唯一的取值方式
auto [lo, hi] = mm.equal_range("k");
// 有序集合：插入即自动去重｜O(log n)｜要允许重复 key 改用 multiset / multimap
std::set<int> s;   s.insert(5);
// 失效规则：插入不使任何迭代器失效，erase 只失效被删那一个 —— 关联容器的迭代器最稳

// ══════ <unordered_map> / <unordered_set> ── 哈希关联容器，无序 ══════
std::unordered_map<std::string, int> um;
// 预留桶数｜O(n)｜避免中途 rehash（rehash 会让所有迭代器失效，但引用仍有效）
um.reserve(1000);
// 计数惯用法｜平均 O(1)｜key 不存在时值初始化为 0，再自增
++um["w"];
// 按 key 删除｜平均 O(1)｜⚠ 哈希冲突严重时最坏退化到 O(n)
um.erase("w");
// 要顺序遍历或区间查询就换回 map；自定义类型当 key 需特化 std::hash + 提供 operator==，见 05 章「让自定义类型进容器」卡

// ══════ <stack> / <queue> ── 容器适配器：受限接口，无迭代器、不可遍历 ══════
// LIFO 栈｜push / top / pop 均 O(1)｜⚠ pop 不返回值，要先 top() 取出再 pop()
std::stack<int> st;   st.push(1);   st.top();   st.pop();
// FIFO 队列｜push / front / pop 均 O(1)｜同样 pop 不返回值
std::queue<int> q;    q.push(1);    q.front();  q.pop();
// 优先队列（堆）｜push / pop 为 O(log n)，top 为 O(1)｜⚠ 默认是大顶堆，top() 给的是最大值
std::priority_queue<int> pq;   pq.push(3);   pq.top();
// 小顶堆的写法｜把第三个模板参数换成 greater｜必须把底层容器 vector 一起写全
std::priority_queue<int, std::vector<int>, std::greater<int>> minq;

#include <algorithm>   // 通用算法
#include <numeric>     // 数值：accumulate/reduce/iota/partial_sum/gcd…
#include <iterator>    // back_inserter 等插入迭代器
std::vector<int> v{5,2,8,1,9}, a{1,3,5}, b{2,3,4}, out;  // 示例数据；out 收集结果
auto pred = [](int x){ return x > 0; };   // 谓词
auto fn   = [](int x){ return x * x; };    // 一元变换

/* —— 排序与重排 —— */
std::sort(v.begin(), v.end());                 // 升序 O(n log n)，传 comp 可改序
std::stable_sort(v.begin(), v.end());          // 保持相等元素的原相对次序
std::partial_sort(v.begin(), v.begin()+3, v.end()); // 只把最小 3 个排到最前
std::nth_element(v.begin(), v.begin()+2, v.end());  // 让第 3 名就位、两侧仅粗分（选第 k 名）
std::reverse(v.begin(), v.end());              // 原地反转
std::rotate(v.begin(), v.begin()+2, v.end());   // 循环左移，使第 3 个元素成为新开头
bool srt = std::is_sorted(v.begin(), v.end()); // 是否已升序
std::next_permutation(v.begin(), v.end());     // 生成下一个字典序排列

/* —— 查找与二分（二分类要求区间已排序） —— */
auto it = std::find(v.begin(), v.end(), 8);     // 顺序查找，找不到返回 end()
auto ev = std::find_if(v.begin(), v.end(), [](int x){ return x%2==0; }); // 找第一个满足谓词者
int  n  = std::count(v.begin(), v.end(), 8);    // 统计等于值的个数（count_if 用谓词）
auto aj = std::adjacent_find(v.begin(), v.end()); // 首个「相邻相等」处
bool in = std::binary_search(v.begin(), v.end(), 8); // 已排序区间判在否
auto lo = std::lower_bound(v.begin(), v.end(), 8); // 首个 ≥ 值的位置；upper_bound 为首个 > 值

/* —— 判定与比较 —— */
bool pos = std::all_of(v.begin(), v.end(), pred); // 全满足？any_of / none_of 同理
bool eq  = std::equal(a.begin(), a.end(), b.begin()); // 两区间逐元素相等？
auto ms  = std::mismatch(a.begin(), a.end(), b.begin()); // 首个不同处的一对迭代器

/* —— 极值与夹取 —— */
auto mx = std::max_element(v.begin(), v.end());   // 区间最大元素的迭代器；min_element 同理
auto [pmn, pmx] = std::minmax_element(v.begin(), v.end()); // 一次拿到最小 / 最大位置
int  hi = std::max({3, 9, 5});               // 对「若干值」取极值（区别于 _element 版）
int  y  = std::clamp(y0, 0, 10);            // 夹取单个标量，非区间算法（C++17）

/* —— 变换 · 生成 · 拷贝 · 删除 —— */
std::transform(v.begin(), v.end(), v.begin(), fn); // 逐元素变换，可写回原地
std::for_each(v.begin(), v.end(), [](int x){ std::print("{}", x); }); // 逐元素执行副作用
std::copy_if(v.begin(), v.end(), std::back_inserter(out), pred); // 条件拷贝到 out
std::generate(v.begin(), v.end(), []{ return 0; }); // 用函数逐个生成（fill 是常量版、iota 是递增版）
std::replace(v.begin(), v.end(), 0, -1);      // 把所有 0 换成 -1
auto mid = std::remove_if(v.begin(), v.end(), pred); // 前移保留元素、返回新逻辑末尾…
v.erase(mid, v.end());                        // …必须配 erase 才真正删除（见 pitfall）

/* —— 划分 —— */
auto pt = std::partition(v.begin(), v.end(), pred); // 满足谓词的挪到前段，返回分界迭代器
std::stable_partition(v.begin(), v.end(), pred); // 同上但保持相对次序

/* —— 有序集合运算（输入须已排序） —— */
std::merge(a.begin(),a.end(), b.begin(),b.end(), std::back_inserter(out)); // 归并两个有序区间
std::set_union(a.begin(),a.end(), b.begin(),b.end(), std::back_inserter(out)); // 并集；另有 set_intersection / set_difference
bool sub = std::includes(a.begin(),a.end(), b.begin(),b.end()); // a 是否包含 b（子集判定）

/* —— 归约与前缀（<numeric>） —— */
int sum = std::accumulate(v.begin(), v.end(), 0); // 求和 / 归约，第三参为初值
int dot = std::inner_product(v.begin(), v.end(), v.begin(), 0); // 内积 Σ vᵢ²
std::partial_sum(v.begin(), v.end(), out.begin());  // 前缀和 → out
std::adjacent_difference(v.begin(), v.end(), out.begin()); // 相邻差分 → out
int g = std::gcd(12, 18), l = std::lcm(4, 6); // 最大公约 / 最小公倍（C++17）
int rd  = std::reduce(v.begin(), v.end());   // C++17 可并行版 accumulate（求值无序）

/* —— 去重与删除（配合 erase） —— */
v.erase(std::unique(v.begin(), v.end()), v.end()); // 先 sort 再删相邻重复
std::erase_if(v, pred);                          // C++20：一步删除满足谓词者

/* —— C++20 ranges：省 begin/end · 可管道（详见 10 章 Ranges 卡）· 支持投影 —— */
std::ranges::sort(v);                          // 直接传整个容器，等价于 sort(v.begin(), v.end())
std::ranges::sort(people, {}, &Person::age);      // 投影：按成员排序，无需手写 comp
auto view = v | std::views::filter(pred)
              | std::views::transform(fn)
              | std::views::take(3);            // 惰性视图链；另有 drop / reverse / join
// C++23：auto vec = view | std::ranges::to<std::vector>();  // 惰性结果收集回容器

// ══════ <string> ── 拥有型字符串：自己管理内存，可增可改 ══════
std::string str = "hi";
// 追加｜摊还 O(追加长度)｜可能重新分配，此后所有指向内部的指针/迭代器失效
str += "!";
// 追加 n 个重复字符｜O(n)｜常用于补齐 / 画分隔线
str.append(3, '.');
// 取子串｜O(子串长度)｜⚠ 会拷贝一份新 string；只读场景改用 string_view 免拷贝
str.substr(1, 2);
// 查找子串首次出现位置｜O(n·m)｜⚠ 找不到返回 std::string::npos（一个巨大的无符号数），不是 -1
str.find("i");
// 前缀判断｜O(前缀长度)｜C++20；另有 ends_with（同 C++20）与 contains（C++23）
str.starts_with("h");
// 取出 const char* 交给 C 接口｜O(1)｜⚠ str 一旦修改或析构，该指针立刻失效
str.c_str();

// ══════ <string_view> ── 只读非拥有视图：零拷贝，但只是「借」 ══════
// 从 string 构造只读视图｜O(1)，不分配不拷贝｜⚠ 不延长源串寿命，别比源串活得久，更别 return 局部串的 view
std::string_view sv = str;
// 函数参数首选它｜O(1) 传递｜string / const char* / 字面量都能隐式转进来，一个签名通吃
void log(std::string_view msg);

// ══════ <format> / <charconv> ── 格式化与数字转换 ══════
// C++20 类型安全格式化｜取代 printf｜格式串错误在编译期就报，不会像 printf 那样运行期才炸
std::format("{}-{:.2f}", 1, 3.14159);      // → "1-3.14"
// 最快的「字符串→数字」｜不抛异常、不分配、不认 locale｜返回 {ptr 停在首个未消费字符, ec}，必须检查 ec
auto [ptr, ec] = std::from_chars(p, p + n, out);
// 最快的「数字→字符串」｜写进你给的缓冲，不分配｜⚠ 缓冲不够时 ec 为 errc::value_too_large，不会截断也不报错
char buf[16];
auto [p2, ec2] = std::to_chars(buf, buf + sizeof buf, 3.14);
// 老接口：简单但慢｜stoi 越界或非法输入会抛异常，to_string 对浮点精度不可控
std::stoi("42");   std::to_string(42);

// ══════ <regex> ── 正则（语法本身见「正则表达式」专页）══════
// 构造正则对象｜⚠ 构造开销很大（要编译成状态机），务必提到循环外复用
std::regex re(R"(\d+)");
// 在串中搜索首个匹配｜结果放进 match_results｜另有 regex_match（要求整串匹配）/ regex_replace
std::regex_search(str, mt, re);

#include <sstream>
#include <algorithm>
#include <cctype>

// ══ 切分：没有 split，最稳的是 getline + 分隔符 ══
std::vector<std::string> parts;
std::istringstream iss("a,b,c");
for (std::string tok; std::getline(iss, tok, ','); )
    parts.push_back(tok);            // {"a","b","c"}；C++20 另有 views::split

// ══ 去空白 trim：find_first/last_not_of 掐两头 ══
std::string t = "  hi  ";
auto a = t.find_first_not_of(" \t\n");
auto z = t.find_last_not_of(" \t\n");
std::string trimmed = (a == std::string::npos)
    ? "" : t.substr(a, z - a + 1);   // "hi"

// ══ 大小写：transform + tolower/toupper，先转 unsigned char ══
std::string low = "AbC";
std::transform(low.begin(), low.end(), low.begin(),
    [](unsigned char ch){ return std::tolower(ch); });  // "abc"

// ══ 字符分类 <cctype>：同样必须转 unsigned char ══
std::isdigit((unsigned char)'7');  // isspace / isalpha / isalnum 同理

// ══ 全局替换：循环 find + replace，从替换点之后继续找 ══
std::string p = "a.b.c";
for (std::size_t i = 0; (i = p.find('.', i)) != std::string::npos; ++i)
    p.replace(i, 1, "/");            // "a/b/c"

// ══════ <memory> ── 智能指针与所有权（原理详见 08 章）══════
// 创建独占所有权的堆对象｜一次分配｜默认就选它，别裸 new；不可拷贝，只能 std::move 转交
auto up = std::make_unique<T>(args);
// 像裸指针一样使用｜O(1)｜零运行期开销，unique_ptr 与裸指针一样大
up->f();   *up;
// 取出裸指针给旧接口用｜O(1)｜⚠ 只是「借看」，绝不能让对方 delete 它
up.get();
// 创建共享所有权的堆对象｜控制块与对象一次分配｜引用计数归零才析构
auto sh = std::make_shared<T>(args);
// 弱引用，不增加计数｜用来打破 shared_ptr 循环引用｜⚠ 用前必须 wp.lock() 提升并判空
std::weak_ptr<T> wp = sh;
// ⚠ shared_ptr 只有「引用计数」本身线程安全；它指向的对象仍要你自己加锁

// ══════ <optional> ── 「可能没有值」，比返回 -1 / 空指针表意清楚 ══════
std::optional<int> opt = 7;
// 判空后解引用取值｜O(1)｜⚠ 空时 *opt 是 UB；不确定就别用 *
if (opt) *opt;
// 取值，空则抛异常｜O(1)｜抛 std::bad_optional_access，比 UB 安全
opt.value();
// 取值，空则用默认值｜O(1)｜最省心的取法，不用先判空
opt.value_or(0);

// ══════ <variant> ── 类型安全的 union：几个类型选其一 ══════
std::variant<int, std::string> var = 42;
// 按类型取值｜O(1)｜⚠ 当前存的不是该类型时抛 std::bad_variant_access
std::get<int>(var);
// 对当前实际类型分派处理｜O(1)｜编译期检查是否覆盖了全部类型，漏一个就编译不过
std::visit(f, var);
// <any>：持有任意类型，取值时必须知道确切类型｜⚠ 类型不符抛 bad_any_cast；能用 variant 就别用它（无编译期检查）
std::any an = 42;   std::any_cast<int>(an);

// ══════ <utility> / <tuple> ── 打包多个值 ══════
// 两个值打包，并用结构化绑定拆开｜O(1)｜C++17 起 pair/tuple 支持类模板参数推导，不用写类型
std::pair pr{1, 2};   auto [x, y] = pr;
// 任意多个值打包，按位置取｜O(1)｜下标必须是编译期常量
std::tuple tp{1, "a"};   std::get<0>(tp);
// 转成右值 / 完美转发｜O(1)，纯编译期｜⚠ std::move 不移动任何东西，只是一次类型转换，见 04 章
std::move(x);   std::forward<T>(x);

// ══════ <numeric> / <cmath> / <limits> ── 数值 ══════
// 区间求和 / 归约｜O(n)｜⚠ 初值类型决定累加类型：对 double 传 0 会整数截断，必须传 0.0
std::accumulate(b, e, 0.0);
// 可并行的归约版本｜O(n)，可指定并行策略｜C++17；要求操作满足结合律与交换律，否则结果不确定
std::reduce(b, e, 0.0);  // 完整归约/前缀家族见本章「算法速查」卡
// 最大公约数 / 最小公倍数｜O(log n)｜C++17
std::gcd(12, 18);   std::lcm(4, 6);
// 把值夹进 [lo, hi]｜O(1)｜⚠ 它住在 <algorithm> 而不是 <numeric>
std::clamp(x, 0, 10);
// 取类型的上下限｜编译期常量｜替代硬编码 INT_MAX，换类型时不用改代码
std::numeric_limits<int>::max();
// 常用数学函数｜O(1)｜注意 std::abs 对整数和浮点有不同重载，别用 C 的 abs()
std::sqrt(2.0);   std::abs(-3);

// ══════ <random> ── 随机数：引擎 + 分布，永远是两件东西 ══════
// 引擎：产生原始随机位｜⚠ 只播种一次、长期持有，别在每次调用里新建（那样序列会重复）
std::mt19937 rng{std::random_device{}()};
// 分布：把引擎输出映射到需要的范围｜闭区间 [1, 6]｜换范围就换分布对象，别自己取模
std::uniform_int_distribution<> dist(1, 6);
// 取一个随机数｜把引擎交给分布调用
dist(rng);
// ⚠ 别用 rand() % n：低位随机性差，且取模会让分布不均（前几个值概率偏高）

// ══════ <chrono> ── 时间点、时长与时钟 ══════
// 取当前时间点｜O(1)｜⚠ 测耗时必须用 steady_clock（单调递增，不受系统改表影响）
auto t0 = std::chrono::steady_clock::now();
// 两个时间点相减得 duration，再转成想要的单位｜duration_cast 会截断（向零取整），不四舍五入
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::steady_clock::now() - t0).count();
// 时长字面量：100ms / 2s / 5min｜需先 using namespace std::chrono_literals
using namespace std::chrono_literals;
std::this_thread::sleep_for(100ms);          // sleep_for 本身在 <thread> 里
// 要「墙上时间 / 日历」用 system_clock（可能被用户改表跳变）；C++20 起有 year_month_day 与时区支持

// ══════ <iostream> ── 标准输入输出 ══════
// 输出并换行｜'\n' 比 std::endl 快得多：endl 每次都强制刷新缓冲区
std::cout << x << '\n';
// 整行读入（含空格）｜⚠ operator>> 会在空白处停下，读整行只能用 getline
std::getline(std::cin, line);
// ⚠ 先 cin >> n 再 getline 会读到空行：>> 把换行符留在了缓冲里，中间需 cin.ignore()

// ══════ <fstream> ── 文件流 ══════
// 打开文件用于读｜析构时自动关闭（RAII），不用手动 close
std::ifstream fin("a.txt");
// 检查是否打开成功｜⚠ 流可隐式转 bool，但失败时不抛异常——不判断就往下读会读到一堆垃圾
if (!fin) { /* 打开失败，及早返回 */ }
// 逐行读到文件尾｜把读取本身作为循环条件，这是唯一正确的写法
while (std::getline(fin, line)) { }
// ⚠ 别写 while (!fin.eof())：eof 要等「读失败之后」才置位，会多循环一次处理空行
// 打开文件用于写｜默认清空原内容，要追加传 std::ios::app
std::ofstream fout("b.txt");

// ══════ <sstream> ── 内存字符串流 ══════
// 往内存里拼字符串，再取出结果｜⚠ 拼装较慢，热点路径改用 std::format
std::ostringstream oss;   oss << 3;   oss.str();
// 把字符串当输入流解析｜适合切分一行里的多个字段
std::istringstream iss(line);   iss >> a >> b;

// ══════ <filesystem> ── 文件系统（C++17）══════
namespace fs = std::filesystem;
// 判断存在 / 取大小 / 递归建目录｜⚠ exists 与后续操作之间存在竞态，别依赖它保证安全
fs::exists(p);   fs::file_size(p);   fs::create_directories(p);
// 遍历目录下的条目｜非递归｜递归版是 recursive_directory_iterator
for (const auto& e : fs::directory_iterator(".")) e.path();
// 每个函数都有「抛异常」与「填 error_code」两个重载，后者适合不用异常的代码库
std::error_code ec;   fs::remove(p, ec);

// ══════ <thread> ── 线程 ══════
// 启动一个线程｜C++20：析构时自动 join 并支持请求停止｜优于裸 std::thread
std::jthread t([]{ /* ... */ });
// ⚠ 裸 std::thread 若析构前既没 join 也没 detach，会直接 std::terminate 掉整个进程

// ══════ <mutex> ── 互斥与 RAII 上锁 ══════
std::mutex mx;
// 进入作用域上锁、离开自动解锁｜⚠ 别手写 lock/unlock：中途 return 或抛异常就会漏解锁 → 死锁
{ std::lock_guard lk(mx); /* 临界区 */ }
// 需要中途解锁 / 配合条件变量时用它｜比 lock_guard 略贵，但可手动 unlock、可移动
{ std::unique_lock lk(mx); cv.wait(lk, []{ return ready; }); }
// 一次锁多个互斥量｜C++17｜⚠ 分别上锁易死锁，多锁必须用 scoped_lock 一把锁全（内部有防死锁算法）
{ std::scoped_lock lk(mx1, mx2); }

// ══════ <atomic> ── 无锁原子操作 ══════
// 单个变量的原子增减｜比加锁快得多｜⚠ 只保证单个变量原子，多个变量间的一致性它管不了
std::atomic<int> cnt{0};   cnt.fetch_add(1);

// ══════ <future> ── 异步任务与结果传递 ══════
// 异步跑一个任务并拿到 future｜⚠ 不写 std::launch::async 时标准允许「根本不开线程」，等你 get() 才同步执行
auto fut = std::async(std::launch::async, []{ return 42; });
// 阻塞等待并取结果｜⚠ 只能调用一次，第二次调用是 UB；任务里抛的异常会在这里重新抛出
fut.get();

// ══════ <type_traits> / <concepts> ── 类型层（详见 07 章）══════
// 编译期判断类型并在不满足时报错｜零运行期开销｜错误信息比模板报错友好得多
static_assert(std::is_integral_v<int>);
// C++20 现成 concept：std::integral / floating_point / same_as / convertible_to / ranges::range

// ══════ <stdexcept> / <expected> ── 错误处理 ══════
// 抛出标准异常｜另有 logic_error / out_of_range / invalid_argument｜捕获时用 const& 接，避免切片
throw std::runtime_error("boom");
// C++23：不抛异常地返回「值 或 错误」｜错误信息带类型，比 optional 多告诉你「为什么失败」
std::expected<int, Err> r = f();

// ══════ <cXXX> ── 整套 C 标准库并入 std 命名空间 ══════
// <cmath> <cstring> <cstdlib> <cstdio> <cctype> <ctime>… 即 C 的 math.h / string.h / …（详见「工程基础」页 04 章）
// 名字进了 std::，语义仍是 C 的（无边界检查、无异常、无 RAII）
std::strlen("hi");   std::memcpy(d, s, n);   std::atoi("1");
// 但日常应优先用 C++ 对应物：string / string_view 替 strXXX，from_chars 替 atoi，format 替 printf

// 函数模板
template<typename T>
T max_val(T a, T b) {
    return (a > b) ? a : b;
}

max_val(3, 7);           // T = int，自动推导
max_val(3.14, 2.72);     // T = double

// 类模板
template<typename T, int N>
class FixedArray {
    T data_[N];
public:
    T& operator[](int i) { return data_[i]; }
    constexpr int size() const { return N; }
};

FixedArray<double, 10> arr;  // 10 个 double 的固定数组

// 主模板
template<typename T>
struct is_pointer { static constexpr bool value = false; };

// 偏特化：对「任意 T*」
template<typename T>
struct is_pointer<T*> { static constexpr bool value = true; };

static_assert(is_pointer<int*>::value);   // true
static_assert(!is_pointer<int>::value);    // false

#include <concepts>

// 定义概念
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// 用法一：requires 子句
template<typename T>
    requires Numeric<T>
T add(T a, T b) { return a + b; }

// 用法二：简写（推荐）
auto multiply(Numeric auto a, Numeric auto b) {
    return a * b;
}

add(1, 2);          // ✅ OK
add("a", "b");      // ❌ 编译错误：const char* 不满足 Numeric

#include <type_traits>

// enable_if：只对整数类型启用这个重载
template<typename T,
         typename = std::enable_if_t<std::is_integral_v<T>>>
void f(T x) { /* 只有 T 是整数时才可见 */ }

// void_t 检测：T 是否有 ::value_type
template<typename, typename = void>
struct has_value_type : std::false_type {};
template<typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

// C++20 同一意图一行搞定，报错还可读：
// template<std::integral T> void f(T x);

// C++17 折叠表达式：优雅地展开参数包
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);  // 右折叠：a + (b + (c + d))
}

sum(1, 2, 3, 4);  // 10

// 打印所有参数
template<typename... Args>
void print(Args&&... args) {
    (std::cout << ... << args) << '\n';
}

print("x=", 42, ", y=", 3.14);
// 输出：x=42, y=3.14

// 完美转发（保持参数的值类别）
template<typename T, typename... Args>
std::unique_ptr<T> make(Args&&... args) {
    return std::make_unique<T>(std::forward<Args>(args)...);
}

// 完美转发：把参数原封不动（保持左右值）传给构造
template<typename T>
void wrapper(T&& arg) {          // T&& = 转发引用
    consume(std::forward<T>(arg)); // 左值→左值，右值→右值
}

int x = 1;
wrapper(x);        // 左值实参 → T=int&，折叠成 int&，forward 转出左值
wrapper(42);       // 右值实参 → T=int，forward 转出右值

// 变参 + 完美转发 = emplace 的实现套路
template<typename... Args>
void emplace(Args&&... args) {
    new (slot) T(std::forward<Args>(args)...);
}

// constexpr 函数：编译期 + 运行期都能用（多语句体需 C++14）
constexpr int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

constexpr int f5 = factorial(5);  // 编译期计算 = 120

// if constexpr：编译期分支（C++17）
template<typename T>
std::string to_str(T val) {
    if constexpr (std::is_integral_v<T>) {
        return std::to_string(val);
    } else if constexpr (std::is_same_v<T, std::string>) {
        return val;
    } else {
        return "???";
    }
}

// 单个对象：new 配 delete
int* p = new int(42);   // 堆上分配 + 构造，返回指针
std::print("{}", *p);       // 解引用用它
delete p;                   // 析构 + 归还内存（漏掉 = 泄漏）
p = nullptr;                // 置空，避免悬垂 / 双重释放

// 数组：new[] 必须配 delete[]
int* arr = new int[10]{};  // 10 个 int，全部零初始化
arr[0] = 1;
delete[] arr;                // ⚠️ 少了 [] 就是 UB

// 四类典型错误
int* a = new int(1);
// delete a; delete a;      // ❌ 双重释放 → 堆损坏
// delete a; *a = 2;        // ❌ 悬垂：use-after-free

void leaky() {
    int* buf = new int[256];
    mayThrow();                // ⚠️ 一旦抛异常，下面的 delete 被跳过
    delete[] buf;               // 正常路径才走到 → 异常路径泄漏
}

#include <memory>

// unique_ptr：独占所有权（首选）
auto p1 = std::make_unique<int>(42);
// auto p2 = p1;  ❌ 编译错误：不能拷贝
auto p2 = std::move(p1);  // ✅ 可以移动

// shared_ptr：共享所有权
auto sp1 = std::make_shared<std::string>("hello");
auto sp2 = sp1;  // 引用计数 = 2
sp1.use_count(); // 2

// weak_ptr：打破循环引用
std::weak_ptr<std::string> wp = sp1;
if (auto locked = wp.lock()) {
    std::print("{}", *locked);  // 安全访问
}

// 自定义删除器：用 unique_ptr 管 FILE*
std::unique_ptr<FILE, decltype(&fclose)>
    fp(fopen("data.txt", "r"), &fclose);  // 离开作用域自动 fclose

// 数组所有权
std::unique_ptr<int[]> buf(new int[256]);      // 自动 delete[]

// shared_from_this：安全地把自己交出去
struct Session : std::enable_shared_from_this<Session> {
    void start() {
        asyncCall([self = shared_from_this()]{ self->onDone(); }); // 寿命延长到回调
    }
    void onDone();
};

// RAII 的典型例子：lock_guard
std::mutex mtx;
{
    std::lock_guard<std::mutex> lock(mtx);
    // 持有锁，做一些操作...
    // 即使抛出异常，lock 的析构函数也会释放锁
}  // 离开作用域，自动解锁

// 自定义 RAII 包装器
class FileHandle {
    FILE* fp_;
public:
    FileHandle(const char* path, const char* mode)
        : fp_(std::fopen(path, mode)) {
        if (!fp_) throw std::runtime_error("open failed");
    }
    ~FileHandle() { if (fp_) std::fclose(fp_); }

    // 禁止拷贝，允许移动
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
};

#include <stdexcept>

// 抛出与捕获
double divide(int a, int b) {
    if (b == 0)
        throw std::runtime_error("division by zero");
    return static_cast<double>(a) / b;
}

try {
    auto r = divide(1, 0);
} catch (const std::exception& e) {  // 按 const 引用捕获基类
    std::cerr << e.what();            // "division by zero"
}

// 标准异常层次：std::exception 是根
//   ├─ logic_error   （invalid_argument / out_of_range …）
//   └─ runtime_error （overflow_error / system_error …）

// noexcept：承诺不抛异常（移动操作应标记）
void cleanup() noexcept { /* 一旦抛异常直接 terminate */ }

int n = 0;
assert(++n > 0);
printf("n=%d\n", n);

调试构建     → n=1
-DNDEBUG    → n=0   ← 那个 ++n 彻底消失了

r.out: r.cpp:3: int main(): Assertion `x==1' failed.
exit=134   （128 + 6，即 SIGABRT）

constexpr int half(int x){ assert(x % 2 == 0); return x / 2; }

static_assert(half(4) == 2);   → 通过（条件为真，assert 不求值）
static_assert(half(3) == 1);   → error: call to non-'constexpr' function
                                  '__assert_fail'

int f(int x) pre(x > 0) post(r: r > 0) { return x; }
int g(int x){ contract_assert(x > 0); return x; }

g++ 15.2  -std=c++2c        → error: expected initializer before 'pre'
g++ 15.2  -std=c++2c -fcontracts → 同样报错
clang++ 21.1.8 -std=c++2c   → error: expected function body after function declarator

#include <cassert>
#include <expected>
#include <utility>   // std::unreachable（C++23）

// —— ① 外部世界可能失败 → 返回 expected，发布版照样检查 ——
auto parse_port(std::string_view s) -> std::expected<int, std::string> {
    int v{};
    auto [p, ec] = std::from_chars(s.data(), s.data() + s.size(), v);
    if (ec != std::errc{} || v < 1 || v > 65535)
        return std::unexpected("端口非法");   // 用户输入错 —— 不是 bug
    return v;
}

// —— ② 调用方违约 → 断言，发布版删掉 ——
void fill(int* dst, int n, int v) {
    assert(dst != nullptr && "dst 不能为空");  // 字符串恒真，只为让报错可读
    assert(n >= 0);
    for (int i = 0; i < n; ++i) dst[i] = v;
}

// —— ③ 编译期就能判的 → static_assert，NDEBUG 也删不掉 ——
template <typename T>
void send_raw(const T& v) {
    static_assert(std::is_trivially_copyable_v<T>,
                  "只能直接发送可平凡复制的类型");
    // …
}

// —— ④ assume / unreachable：告诉优化器，不做检查 ——
int parity(int x) {
    switch (x & 1) {
        case 0: return 0;
        case 1: return 1;
        default: std::unreachable();   // 到不了；真走到就是 UB
    }
}

// 反例：这一句在 -DNDEBUG 下什么都不做，check() 根本不会被调用
// assert(check() == 0);

class Widget {
    int* data_;
    std::size_t n_;
public:
    friend void swap(Widget& a, Widget& b) noexcept {
        std::swap(a.data_, b.data_);
        std::swap(a.n_, b.n_);
    }
    // 按值传参 = 复用拷贝构造；再 swap → 强保证 + 自赋值安全
    Widget& operator=(Widget rhs) noexcept {
        swap(*this, rhs);
        return *this;
    }
    // 移动构造标 noexcept，vector 扩容才会「移动」而非「拷贝」
    Widget(Widget&& o) noexcept : data_(o.data_), n_(o.n_) { o.data_ = nullptr; }
};

// 常见错误示例

// 1. 悬垂引用
int& bad() {
    int x = 42;
    return x;  // ⚠️ x 离开作用域就销毁了！
}

// 2. 迭代器失效
std::vector<int> v = {1, 2, 3};
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it == 2) v.erase(it);  // ⚠️ erase 后 it 失效！
}
// 正确写法：it = v.erase(it);

// 编译时开启 Sanitizer 检测
// g++ -fsanitize=address,undefined -g code.cpp
// clang++ -fsanitize=memory -g code.cpp

#include <thread>

// C++11：std::thread
void work(int id) {
    std::println("Thread {} running", id);
}

std::thread t1(work, 1);
std::thread t2(work, 2);
t1.join();
t2.join();

// C++20：std::jthread（自动 join + 支持取消）
{
    std::jthread jt([](std::stop_token st) {
        while (!st.stop_requested()) {
            // 工作循环，可被外部请求停止
        }
    });
}  // jt 离开作用域自动 request_stop + join

#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
std::queue<int> tasks;

// 生产者
void produce(int val) {
    {
        std::lock_guard lock(mtx);  // C++17 CTAD
        tasks.push(val);
    }
    cv.notify_one();  // 唤醒一个等待者
}

// 消费者
void consume() {
    std::unique_lock lock(mtx);
    cv.wait(lock, []{ return !tasks.empty(); });
    int val = tasks.front();
    tasks.pop();
}

#include <mutex>
#include <shared_mutex>

std::mutex m1, m2;
// 一次锁两把，内部避免死锁（不用管顺序）
{
    std::scoped_lock lk(m1, m2);   // C++17
    /* 临界区 */
}

// 读写锁：读并发、写独占
std::shared_mutex sm;
int read() {
    std::shared_lock lk(sm);       // 多个读者可同时持有
    return shared_data;
}
void write(int v) {
    std::unique_lock lk(sm);       // 写者独占
    shared_data = v;
}

#include <future>

// async：最简单的异步
auto fut = std::async(std::launch::async, []() {
    // 在另一个线程里执行耗时计算
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
});

// 做其他事情...

int result = fut.get();  // 阻塞等待结果：42

// promise + future：手动通信通道
std::promise<std::string> prom;
std::future<std::string> fut2 = prom.get_future();

std::thread t([&prom]() {
    prom.set_value("done");
});

std::print("{}", fut2.get());  // "done"
t.join();

#include <atomic>

std::atomic<int> counter{0};

// 多线程安全地递增
void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter.fetch_add(1);  // 原子加
        // 或 counter++; 也是原子操作
    }
}

// 原子标志位
std::atomic<bool> ready{false};
// 线程 A：
ready.store(true);
// 线程 B：
while (!ready.load()) { /* 等待 */ }

#include <atomic>

// relaxed：纯计数器，不需要排序
std::atomic<int> counter{0};
counter.fetch_add(1, std::memory_order_relaxed);

// release/acquire 配对：发布数据 + 标志
std::atomic<bool> ready{false};
data = 42;                                    // 生产者
ready.store(true, std::memory_order_release);  // 之前的写对 acquire 可见
while (!ready.load(std::memory_order_acquire)) {} // 消费者
// 此处读 data 一定是 42

// CAS 循环：无锁地累加
int old = counter.load();
while (!counter.compare_exchange_weak(old, old + 1)) {}

// 躲伪共享：让每个热点计数器独占一整条 cache line
struct alignas(64) Padded { std::atomic<long> v; };

#include <latch>
#include <barrier>
#include <semaphore>
#include <thread>

// —— latch：主线程等 3 个 worker 都就绪（一次性）——
std::latch ready{3};
for (int i = 0; i < 3; ++i)
    std::thread([&]{ /* init... */ ready.count_down(); }).detach();
ready.wait();                          // 三个都 count_down 后才继续

// —— barrier：N 个线程分代同步，每代到齐跑一次收尾 ——
std::barrier sync(3, []{ std::println("本代完成"); });  // 到齐时执行的完成函数
// 每个线程循环里调 sync.arrive_and_wait(); 到齐才进入下一代

// —— counting_semaphore：最多 2 个线程同时用受限资源 ——
std::counting_semaphore<2> slots{2};
slots.acquire();                       // 拿一个名额（没有则阻塞）
/* ... 使用受限资源 ... */
slots.release();                       // 归还名额

#include <ranges>
#include <vector>

std::vector<int> nums = {1,2,3,4,5,6,7,8,9,10};

// 管道：取偶数 → 平方 → 前 3 个
auto result = nums
    | std::views::filter([](int n){ return n % 2 == 0; })
    | std::views::transform([](int n){ return n * n; })
    | std::views::take(3);

// result: [4, 16, 36]（惰性求值，不产生中间容器）
for (int x : result) std::print("{} ", x);

// 对比传统写法（需要中间变量和多次遍历）
// ranges 版本更简洁且无中间容器开销

#include <format>

std::string name = "C++";
int version = 20;

// std::format（C++20）
std::string s = std::format("Hello, {}{}!", name, version);
// "Hello, C++20!"

// 格式说明符
std::format("{:>10}", 42);     // "        42"（右对齐）
std::format("{:#06x}", 255);   // "0x00ff"（十六进制）
std::format("{:.2f}", 3.14159); // "3.14"（保留两位小数）

// std::print（C++23）—— 直接输出，不需要 cout
// std::print("Hello, {}!\n", name);

#include <generator>   // C++23

// 惰性斐波那契：co_yield 逐个产出，产出后挂起
std::generator<int> fib() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;              // 挂起，下次从这里恢复
        auto next = a + b; a = b; b = next;
    }
}

for (int x : fib() | std::views::take(10))
    std::print("{} ", x);   // 0 1 1 2 3 5 8 13 21 34

// 异步：co_await 一个 awaitable，挂起而不阻塞线程
Task<std::string> fetch() {
    auto conn = co_await connect();
    co_return conn.read();
}

#include <expected>   // C++23

std::expected<int, std::string> parse(std::string_view s) {
    if (s.empty())
        return std::unexpected("empty input");   // 失败：带原因
    return std::stoi(std::string(s));            // 成功：直接返回值
}

auto r = parse("42");
if (r) std::print("{}", *r);          // 有值
else   std::print("{}", r.error());  // 拿错误原因

// 单子链：出错自动短路
auto out = parse("10")
    .transform([](int x){ return x * 2; });   // 有值才执行

// math_utils.cppm —— 模块定义
export module math_utils;

export int add(int a, int b) {
    return a + b;
}

export double pi() {
    return 3.14159265358979;
}

// main.cpp —— 使用模块
import math_utils;
import <print>;    // 标准库也可以用 import

int main() {
    std::println("{}", add(1, 2));
}

// —— <bit> 位操作（C++20）：把哈希 / 位图 / 协议字节序里的手写位技巧变成标准函数 ——
#include <bit>
std::popcount(0b1011u);          // 1 的个数 = 3
std::countl_zero(1u);            // 前导 0 个数（用于算 log2 / 对齐）
std::bit_width(37u);             // 表示该数所需位数 = 6
std::has_single_bit(16u);        // 是否 2 的幂 → true
std::bit_cast<int>(3.14f);      // 按位重解释类型（取代 union 双关（UB）和繁琐的 memcpy 惯用法）
std::byteswap(0x1234u);         // 字节序翻转（C++23）

// —— flat_map / flat_set（C++23）：有序但底层是连续数组 ——
std::flat_map<int, std::string> fm;   // 接口同 map，查快、缓存友好，插入慢
// 适合「建好后大量查、极少改」，替代 map 省内存、省指针跳转

// —— mdspan（C++23）：多维视图，不拥有内存（图像像素 / 矩阵线代 / 科学计算，把一维 buffer 当多维用）——
int raw[6] = {1,2,3,4,5,6};
std::mdspan md(raw, 2, 3);            // 把一维缓冲看成 2×3
md[1, 2];                            // 多维下标（C++23 起 operator[] 支持多参）

// —— <print>（C++23）：直接打印，不必 cout << 也不用 format 喂流 ——
#include <print>
std::println("{} + {} = {}", 1, 2, 3);   // 自带换行，类型安全

// —— 诊断类 ——
#include <source_location>
auto loc = std::source_location::current();  // 拿到当前 文件/行/函数（C++20，取代 __FILE__ 宏）
#include <stacktrace>
std::cout << std::stacktrace::current();     // 运行期抓调用栈（C++23）

// ══ 已经能用（GCC 14+ / Clang 19+，-std=c++26）══
template <typename... Ts>
using first = Ts...[0];         // pack 索引：取包里第 0 个类型（P2662）

auto [x, _] = get_pair();          // _ 占位：显式丢弃不用的绑定（P2169）
int y = std::add_sat(INT_MAX, 1);  // 饱和：钳到 INT_MAX，不 UB（P0543）

void old() = delete("请改用 new_api()");  // 删除并给理由（P2573）

static const unsigned char logo[] = {  // #embed：二进制塞进源码（C23/26）
    #embed "logo.png"
};

// ══ 还在实验分支，别用于生产（下面都是示意，主线编译器多半编不过）══
// 静态反射（P2996）：编译期拿类型信息、自动生成代码
// constexpr auto ms = std::meta::nonstatic_data_members_of(^^Point);
// Contracts（P2900）：前置/后置条件进签名
// int div(int a, int b) pre(b != 0) { return a / b; }
// std::execution（P2300）：标准 sender/receiver 异步框架

# Makefile —— 自动收集源文件 + 自动头文件依赖
CXX      := g++
CXXFLAGS := -std=c++23 -Wall -Wextra -O2 -MMD -MP
SRCS     := $(wildcard *.cpp)
OBJS     := $(patsubst %.cpp,%.o,$(SRCS))

app: $(OBJS)
	$(CXX) $(CXXFLAGS) $^ -o $@       # $^=全部 .o  $@=app

%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@    # $<=对应的 .cpp

.PHONY: clean
clean:
	rm -f $(OBJS) $(OBJS:.o=.d) app

-include $(OBJS:.o=.d)   # 引入自动生成的头文件依赖

# make -j8  并行编译   make -n  只打印命令   make -B  强制重建

# CMakeLists.txt 基本结构
cmake_minimum_required(VERSION 3.20)
project(MyApp LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 一组源文件先编成库,再让可执行文件用它
add_library(mylib src/mylib.cpp)
target_include_directories(mylib PUBLIC include/)   # PUBLIC：传给用它的人

add_executable(app src/main.cpp src/utils.cpp)
target_link_libraries(app PRIVATE mylib)          # app 自动获得 mylib 的公开属性

# 配置并构建：
# cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
# cmake --build build -j       ctest --test-dir build

# —— vcpkg 清单模式：vcpkg.json 里声明依赖 ——
# { "dependencies": ["fmt", "spdlog"] }
cmake -B build \
  -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake
# 配置时自动下载/编译/装好；CMakeLists 里照常 find_package(fmt)

# —— FetchContent：CMakeLists.txt 里直接拉，零安装 ——
# include(FetchContent)
# FetchContent_Declare(fmt GIT_REPOSITORY .../fmt GIT_TAG 10.2.1)
# FetchContent_MakeAvailable(fmt)  → target_link_libraries(app fmt)

# —— pkg-config：装系统库后取旗标 ——
sudo apt install libssl-dev
g++ app.cpp $(pkg-config --cflags --libs openssl) -o app

# —— CMakeLists.txt：四行把 gtest 拉进来 ——
#  include(FetchContent)
#  FetchContent_Declare(googletest URL https://github.com/google/
#      googletest/archive/refs/tags/v1.17.0.tar.gz)
#  FetchContent_MakeAvailable(googletest)
#
#  enable_testing()
#  add_executable(demo_test test.cpp)
#  target_link_libraries(demo_test GTest::gtest_main)  # 自带 main
#  include(GoogleTest)
#  gtest_discover_tests(demo_test)   # 让 ctest 逐条看见每个 TEST

#include <gtest/gtest.h>

int add(int a, int b) { return a + b; }

TEST(AddTest, BasicAdd) {          // TEST(套件名, 用例名)
    EXPECT_EQ(add(2, 3), 5);
    EXPECT_EQ(add(-1, 1), 0) << "失败时才打印这句";
}

// —— EXPECT 继续，ASSERT 停下——
TEST(Demo, ExpectKeepsGoing) {
    EXPECT_EQ(1, 2);           // 报一条 Failure…
    EXPECT_EQ(3, 4);           // …这条也照样执行并报出来
}
TEST(Demo, AssertStops) {
    ASSERT_EQ(1, 2);           // 失败即 return
    ADD_FAILURE() << "这行不会被执行";
}

// —— 失败信息会把表达式求值给你看 ——
TEST(Demo, ShowsValues) {
    EXPECT_EQ(0.1 + 0.2, 0.3);
    // Expected equality of these values:
    //   0.1 + 0.2
    //     Which is: 0.30000000000000004
    //   0.3
}

// —— 容器开箱即比 ——
TEST(Demo, Containers) {
    std::vector<int> a{1, 2, 3}, b{1, 2, 3};
    EXPECT_EQ(a, b);           // ✅ 直接比内容
}

// —— 固件：每条用例都会重新构造一次 ——
class VecFixture : public ::testing::Test {
 protected:
    void SetUp() override { v = {1, 2, 3}; }
    // TearDown() 只在需要显式释放时才写；RAII 成员不用
    std::vector<int> v;
};

TEST_F(VecFixture, StartsWithThree) { EXPECT_EQ(v.size(), 3u); }
TEST_F(VecFixture, MutatesIt)       { v.push_back(9);
                                       EXPECT_EQ(v.size(), 4u); }
TEST_F(VecFixture, StillThree)     { EXPECT_EQ(v.size(), 3u); }
// ↑ 三条全过：上一条的 push_back 影响不到下一条


// —— 参数化：一张表跑多组 ——
class ParamTest
    : public ::testing::TestWithParam<std::pair<int, int>> {};

TEST_P(ParamTest, DoublesIt) {
    auto [in, want] = GetParam();
    EXPECT_EQ(in * 2, want);
}
INSTANTIATE_TEST_SUITE_P(Cases, ParamTest,
    ::testing::Values(std::pair{1, 2},
                     std::pair{3, 6},
                     std::pair{5, 11}));   // ← 故意写错的一组

// 展开成三条独立用例，失败那条报：
//   [  FAILED  ] Cases/ParamTest.DoublesIt/2,
//               where GetParam() = (5, 11)     ← 是哪组数据一目了然


// —— 浮点：三种写法，第一种是错的 ——
EXPECT_EQ(0.1 + 0.2, 0.3);              // ❌ 失败
EXPECT_DOUBLE_EQ(0.1 + 0.2, 0.3);       // ✅ 4 ULP 相对误差
EXPECT_NEAR(0.1 + 0.2, 0.3, 1e-9);     // ✅ 自定绝对容差

// CMake：链接目标换成 gmock_main（装了 gtest 就已经有它）
//   target_link_libraries(t GTest::gmock_main)

#include <gmock/gmock.h>
using ::testing::Return;
using ::testing::_;            // 任意参数
using ::testing::StrictMock;

// —— 被依赖的接口：必须有虚函数 ——
class Db {
 public:
    virtual ~Db() = default;
    virtual bool save(const std::string& k, int v) = 0;
    virtual int  load(const std::string& k) = 0;
};

// —— 替身：一个方法一行 ——
class MockDb : public Db {
 public:
    MOCK_METHOD(bool, save, (const std::string&, int), (override));
    MOCK_METHOD(int,  load, (const std::string&), (override));
    //          ↑ 参数表外这对括号不能省：含逗号的类型会被宏拆开
};

TEST(Gmock, SetsExpectation) {
    MockDb db;
    EXPECT_CALL(db, save("k", 1)).Times(1).WillOnce(Return(true));
    EXPECT_CALL(db, load(_)).WillOnce(Return(1));
    EXPECT_TRUE(handle(db));        // ← 期望写在被测代码之前
}

// 期望没被满足 = 用例失败，报错：
//   Actual function call count doesn't match EXPECT_CALL(...)
//     Expected: to be called once
//       Actual: never called - unsatisfied and active
//   参数对不上还会逐个列：
//     Expected arg #0: is equal to "never"    Actual: "k"

// —— 没设期望的调用只是警告，用例照过 ——
TEST(Gmock, JustAWarning) {
    MockDb db;                       // 一个 EXPECT_CALL 都没有
    handle(db);                      // GMOCK WARNING: Uninteresting mock
}                                    //   function call - returning default value
                                     // [       OK ]   ← 通过了！

TEST(Gmock, StrictMakesItFail) {
    StrictMock<MockDb> db;           // 同样的代码
    handle(db);                      // [  FAILED  ]  ← 变成失败
}

# 带调试信息编译（优化会打乱行号与变量）
g++ -g -Og -o app main.cpp

# gdb 常用流程
gdb ./app
(gdb) break main.cpp:42     # 下断点
(gdb) run                   # 运行，崩溃或断点处停下
(gdb) bt                    # backtrace：看调用栈
(gdb) info locals           # 看当前局部变量
(gdb) watch total           # total 被改写时中断
(gdb) print obj.field       # 求值任意表达式

# 事后调试 core dump
ulimit -c unlimited && ./app     # 崩溃生成 core
gdb ./app core                   # 直接跳到崩溃现场

// Pimpl 惯用法：编译防火墙
// widget.h
class Widget {
    struct Impl;              // 前向声明
    std::unique_ptr<Impl> pImpl_;
public:
    Widget();
    ~Widget();
    void doWork();
};

// CRTP：静态多态（零虚函数开销）
template<typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class Concrete : public Base<Concrete> {
public:
    void implementation() {
        std::println("Concrete impl");
    }
};