#include <string>

std::string s = "Hello";
s += " World";                       // 拼接：直接用 + 和 +=
std::cout << s << "\n";              // Hello World

std::cout << s.size() << "\n";       // 11（自带长度，不用扫到 \0）

// 查找：返回首次出现的下标；找不到返回 string::npos（一个特殊大值=没找到）
size_t pos = s.find("World");        // size_t：标准库的"下标专用类型"，当数字看即可
if (pos != std::string::npos) {
    std::cout << "下标：" << pos << "\n";   // 6
}

std::cout << s.substr(0, 5) << "\n"; // Hello（substr(起点, 个数)）

// 比较：直接 ==（对比下一节 C 字符串的天壤之别）
std::cout << (s == "Hello World") << "\n";   // 1

// 数值互转（C++11）
std::string num = std::to_string(42);   // "42"
int    n = std::stoi("123");            // 123
double d = std::stod("3.14");           // 3.14

s[0] = 'h';                          // 按下标改单个字符

// ① 值传递：复印一份，函数改的是复印件
void addTen(int x) { x += 10; }

// ② 引用传递：原件的别名，直接改本体（& 出现在参数类型后面）
void addTenRef(int& x) { x += 10; }

// ③ 指针传递：递"地址条"，函数按地址上门修改（第六章详解指针）
void addTenPtr(int* x) { *x += 10; }

int a = 5, b = 5, c = 5;
addTen(a);       // a 仍是 5（改的是复印件）
addTenRef(b);    // b 变 15 ✅
addTenPtr(&c);   // c 变 15 ✅（注意调用时手动加 & 取地址）

// ④ 工程最重要的惯例：const 引用 —— "只看不改地借原件"
void printName(const std::string& name) {   // 借来只读，不许改
    std::cout << name << "\n";
}
// 为什么不直接值传递？——string 可能很大，复印一份很费；
// const& = 不复印 + 不许改，两全其美

void print(int x)         { std::cout << "整数: " << x << "\n"; }
void print(double x)      { std::cout << "小数: " << x << "\n"; }
void print(std::string s) { std::cout << "文字: " << s << "\n"; }

print(42);     // 自动选"整数版"
print(3.14);   // 自动选"小数版"
print("abc");  // 自动选"文字版"

// ⚠️ 仅返回值类型不同，不构成重载：
// int    f(int);
// double f(int);    // ❌ 与上面冲突，编译报错 —— 派活时看的是"递进来的东西"

// ⚠️ 二义性陷阱：
void g(long x)  { }
void g(double x) { }
// g(42);   // ❌ 编译错误：42 能转 long 也能转 double，编译器选择困难症发作

// 默认参数：给参数一个"保底值"——调用时不传就用保底
double power(double base, int exp = 2);   // ✅ 默认值必须靠右
// double f(int a = 1, int b);   // ❌ 默认参数必须从右往左连续给

power(3);      // 9 （exp 用保底 2）
power(3, 3);   // 27（显式传 exp=3）

// inline：请求编译器把小函数的代码"直接抄进调用处"，省掉跑腿开销
inline int square(int x) {
    return x * x;
}
// 现代编译器很聪明，是否真抄由它定；inline 更多是链接层面的语义（进阶话题）

#include <vector>
#include <algorithm>

// 基本形态
auto square = [](int x) { return x * x; };
std::cout << square(5) << "\n";      // 25

// 最大用武之地：给 sort 递一个"比较标准"（谓词）
std::vector<int> v{3, 1, 4, 1, 5};
std::sort(v.begin(), v.end(), [](int a, int b) {
    return a > b;                    // 返回 true 表示 a 应排前面 → 降序
});
// v → {5, 4, 3, 1, 1}

// 捕获列表 []：决定 lambda 能不能"看见"外面的变量、怎么看见
int threshold = 3;
auto over = [threshold](int x) { return x > threshold; };  // 按值捕获：复印 3 进来
auto over2 = [&threshold](int x) { return x > threshold; }; // 按引用捕获：用原件本体
auto over3 = [=](int x) { return x > threshold; };          // 用到的外部变量全复印
auto over4 = [&](int x) { return x > threshold; };          // 全按引用借（小心悬垂）

std::cout << over(5) << " " << over2(5) << "\n";   // 1 1

int x = 42;          // x 占了柜子，里面放 42
int* p = &x;         // p 是纸条，上面写着 x 的柜子编号

std::cout << p << "\n";    // 0x7ffd...（编号本身，每次运行不同）
std::cout << *p << "\n";   // 42：顺着编号打开柜子取东西

*p = 100;                  // 顺着编号把 100 放进柜子（改的就是 x）
std::cout << x << "\n";    // 100

int* q = nullptr;          // 空指针 = 白纸条：明确表示"哪都不指"
// *q = 1;    // ❌ 对白纸条开门 = 程序崩溃（段错误：访问非法地址）
if (q != nullptr) { /* ... */ }   // 使用前先验纸条，是好习惯

int arr[5] = {10, 20, 30, 40, 50};
int* p = arr;                 // 数组名在表达式里自动"变成"第一格的地址

std::cout << *p << "\n";       // 10 == arr[0]
std::cout << *(p+1) << "\n";   // 20 == arr[1]

// 惊人的事实：p[i] 就是 *(p+i) 的"语法糖"（同一种意思的更顺手写法）
std::cout << p[3] << "\n";     // 40

// 指针加 1 ≠ 地址加 1 字节！而是"前进一格元素"（int 指针 +1 = +4 字节）
// 编译器按指针类型自动换算 —— 这叫指针算术

int x = 10;
int& r = x;         // r 是 x 的外号（定义时必须立刻绑定）

r = 20;             // 叫外号改的也是本体
std::cout << x << "\n";     // 20
std::cout << &r << "\n";   // 和 &x 相同：外号 = 本体

int y = 99;
// int& r2;         // ❌ 外号不能空着（必须定义时绑定）
r = y;              // ⚠️ 注意！这不是"换绑"，而是 x = y（把 y 的值抄给 x）
                    // 引用一生只跟一个人

// 申请单个变量：new 返回地址纸条
int* p = new int(42);       // 仓库里造一个 int，初值 42
std::cout << *p << "\n";    // 42
delete p;                   // 用完必须手动归还！

// 申请一整片
int* arr = new int[100]();  // () 表示全部清零
arr[0] = 1;
delete[] arr;               // ⚠️ 数组必须用 delete[]（配错 = UB）

// new 失败（仓库满了）会抛出 bad_alloc 异常（第九章详解异常）
// 大块分配建议先 reserve 或用容器，别裸 new 巨型数组

// 好习惯：还完立刻把纸条作废
int* q = new int(5);
delete q;
q = nullptr;        // ✅ 之后误用会立刻崩溃报错，而非悄悄出错
                    // （对 nullptr 解引用 = 立刻段错误，问题第一时间暴露）

// 陷阱④的正确写法：
//   要么按值返回（编译器有返回值优化，拷贝没你想的贵）
int good() { int local = 10; return local; }        // ✅ 拷贝值回来
//   要么调用方先给地盘，函数往里填
void fill(int* out) { *out = 10; }                  // ✅ 地盘是调用者的

#include <memory>

// ── unique_ptr：独占管家 —— 同一地盘只能有一个管家（推荐默认）──
auto p = std::make_unique<int>(42);   // 创建并交给管家
std::cout << *p << "\n";              // 像普通指针一样用
// 离开作用域：自动 delete，一行不用写

// auto q = p;            // ❌ 编译错误：独占，不许复印
auto q2 = std::move(p);   // ✅ 只能"移交管家权"（p 从此失业为空）

// ── shared_ptr：共享管家 —— 多个管家共管，数人头 ──
auto a = std::make_shared<int>(10);
{
    auto b = a;           // 人头 1 → 2
    std::cout << *b;
}                         // b 走了：人头 2 → 1，东西还在
                          // a 走了：人头 1 → 0 → 最后走的人负责关灯锁门（自动 delete）

// struct：成员默认 public（对所有人开放）—— 惯例用于"纯数据包"
struct Point {
    double x, y;              // 外部可直接访问
};

// class：成员默认 private（外人免进）—— 惯例用于"有行为、有规矩"的类型
class Student {
private:                       // （class 里可省略，默认就是 private）
    std::string name;          // 🔒 后厨：外部不可直接访问
    int score;
public:
    void setName(std::string n) { name = n; }
    std::string getName() const { return name; }
};

Point pt{1.5, 2.5};            // struct：直接用成员
Student s;
s.setName("Alice");            // class：走窗口（成员函数）
// s.name = "Bob";             // ❌ 编译错误：private 是后厨

class Student {
public:
    // 冒号后面的 name(n), score(s) 叫"初始化列表"：
    // 出生时直接按给定值造成员
    Student(std::string n, int s) : name(n), score(s) {
        std::cout << name << " 构造\n";
    }
    ~Student() {                    // 析构：自动收尾
        std::cout << name << " 析构\n";
    }
private:
    std::string name;
    int score;
};

int main() {
    Student a("Alice", 92);         // 栈对象：作用域结束自动销毁
    {
        Student b("Bob", 85);       // 内层的后出生
    }                               // Bob 析构
    return 0;
}                                   // Alice 析构（与构造顺序相反：后出生的先离开）

class Counter {
public:
    Counter() : count(0) {}

    Counter& increment() {
        ++count;            // 实际是 this->count，this 自动补全
        return *this;       // 返回"我自己"→ 支持连写 c.increment().increment()
    }

    int get() const {       // 尾部 const：签保证书"只看不改"
        return count;
    }

private:
    int count;
};

Counter c;
c.increment().increment().increment();   // 链式调用：3（this 的功劳）
std::cout << c.get() << "\n";           // 3

const Counter fixed;         // const 对象：加了锁的房子
std::cout << fixed.get();   // ✅ 只能调"签过保证书"的 const 函数
// fixed.increment();        // ❌ 编译错误：increment 没签保证书

class Vec2 {
public:
    double x, y;
    Vec2(double x, double y) : x(x), y(y) {}

    // 定义"+"：函数名固定写成 operator运算符
    Vec2 operator+(const Vec2& o) const {
        return Vec2(x + o.x, y + o.y);
    }
    bool operator==(const Vec2& o) const {
        return x == o.x && y == o.y;
    }
};

Vec2 a(1, 2), b(3, 4);
Vec2 c = a + b;               // 编译器翻译成 a.operator+(b)
std::cout << c.x << "," << c.y << "\n";   // 4,6

// 重载 << 让自定义类型能直接 cout（注意：左边是输出流，所以要写成独立函数）
std::ostream& operator<<(std::ostream& os, const Vec2& v) {
    return os << "(" << v.x << "," << v.y << ")";
}
std::cout << c << "\n";       // (4,6) —— cout 和你之间只隔一个重载

class Animal {                 // 基类（父类）
public:
    void eat() { std::cout << "进食\n"; }
protected:                     // 中间档：子类看得见，外人看不见
    int age = 3;
private:                       // 连子类都看不见
    double dna = 0.0;
};

class Dog : public Animal {    // 子类继承了 Animal
public:
    void bark() {
        std::cout << "汪汪（" << age << "岁）\n";   // ✅ protected 子类可用
        // std::cout << dna;    // ❌ private 子类也不行
    }
};

Dog d;
d.eat();      // ✅ 继承来的能力
d.bark();     // 自己的新本事

class Animal {
public:
    virtual void speak() {          // virtual = 标记"子类可改写，调用看真身"
        std::cout << "...\n";
    }
    virtual ~Animal() = default;    // ⚠️ 虚析构！见下方警告
};

class Dog : public Animal {
public:
    void speak() override {         // override：让编译器核对你真的在改写
        std::cout << "汪汪\n";
    }
};

int main() {
    Animal* a = new Dog();          // 基类指针指向子类对象
    a->speak();                     // 汪汪 ✅ 虚函数：按真身调用
    // 若 speak 不是 virtual：输出 "..."（按指针类型定）
    delete a;
}

class Shape {
public:
    virtual double area() const = 0;   // "= 0"：纯虚函数，本类不实现
    virtual ~Shape() = default;
};

// Shape s;    // ❌ 编译错误：抽象类不能实例化

class Circle : public Shape {
public:
    Circle(double r) : r(r) {}
    double area() const override {     // 子类必须实现，否则子类也是抽象类
        return 3.14159 * r * r;
    }
private:
    double r;
};

// 用途：用基类指针统一管理"各种形状"
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>(2));
for (const auto& s : shapes) {
    std::cout << s->area() << "\n";   // 12.5664 —— 各自的正确版本
}

template <typename T>      // T：类型占位符，名字随意
T myMax(T a, T b) {
    return (a > b) ? a : b;
}

std::cout << myMax(3, 5) << "\n";        // 5   → T=int，生成 int 版
std::cout << myMax(2.5, 1.8) << "\n";    // 2.5 → T=double，生成 double 版
std::cout << myMax<double>(3, 2.5);      // 3   显式指定：两种类型混用时手动选
// myMax(3, 2.5);    // ❌ 编译报错：T 推导冲突（int? double?）

#include <vector>
#include <string>

template <typename T>
class Stack {                     // 栈：只能从顶上放/取的容器（先放的后出 LIFO）
public:
    void push(const T& v) { data.push_back(v); }   // 放到顶上
    void pop()            { data.pop_back(); }      // 拿走顶上的
    T    top() const      { return data.back(); }   // 看一眼顶上的
    bool empty() const    { return data.empty(); }
private:
    std::vector<T> data;           // 借 vector 存数据（组合优于重造）
};

Stack<int> si;                     // 用尖括号"填空"占位符 T
si.push(1); si.push(2);
std::cout << si.top() << "\n";     // 2

Stack<std::string> ss;             // 同一个模板，另一份实例
ss.push("hello");

#include <vector>
#include <map>
#include <unordered_map>
#include <set>

std::vector<int> v{3, 1, 2};          // 动态数组（默认首选）

// map：字典 —— 按关键词查值。内部自动保持按 key 排好序
std::map<std::string, int> m;
m["apple"] = 5;                        // 按键存/改
m["banana"] = 3;
std::cout << m["apple"] << "\n";       // 5
std::cout << m.count("pear") << "\n"; // 0（count = 有没有这个键）

// unordered_map：也是字典，但内部用"哈希表"（按姓氏首字母直接翻到那页）
// 查找平均一步到位，代价：内容不按顺序排列
std::unordered_map<std::string, int> um;
um["apple"] = 5;

// set：集合 —— 自动去重 + 排序
std::set<int> s{1, 2, 2, 3};           // 实际存 {1, 2, 3}

// 遍历 map（C++17 结构化绑定：一次取出键和值）
for (const auto& [key, val] : m) {
    std::cout << key << " = " << val << "\n";   // 按字母序输出（map 自动排序）
}

#include <vector>
#include <algorithm>    // sort / find / count_if 住这里
#include <numeric>      // accumulate 住这里

std::vector<int> v{3, 1, 4, 1, 5};

// 排序：升序
std::sort(v.begin(), v.end());                                  // {1,1,3,4,5}
// 降序：换一个比较标准（greater = "左边大于右边才算前"）
std::sort(v.begin(), v.end(), std::greater<int>());
// 用 lambda 自定义：随你定义
std::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });

// 查找：返回"找到的位置"；没找到返回 end()（终点线外 = 没有）
auto it = std::find(v.begin(), v.end(), 4);
if (it != v.end()) {
    std::cout << "找到，下标 " << (it - v.begin()) << "\n";
}

// 求和：从头加到尾，第 3 个参数是"起始值"（从 0 开始加）
int total = std::accumulate(v.begin(), v.end(), 0);

// 按条件计数：lambda 是"是/否"判断标准（谓词）
int big = std::count_if(v.begin(), v.end(), [](int n) { return n > 2; });

// 一次拿到最小和最大：返回一对位置，* 解引用取值
auto [mn, mx] = std::minmax_element(v.begin(), v.end());
std::cout << *mn << " " << *mx << "\n";

#include <stdexcept>
#include <iostream>

double divide(double a, double b) {
    if (b == 0) {
        throw std::invalid_argument("除数不能为零");   // 扔信号球
    }
    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 2) << "\n";    // 5
        std::cout << divide(1, 0) << "\n";     // 这里扔球，下面的行不执行
        std::cout << "这行不会执行\n";
    }
    catch (const std::invalid_argument& e) {     // 具体异常在前
        std::cerr << "参数错误: " << e.what() << "\n";
    }
    catch (const std::exception& e) {            // "万类异常之父"兜底在后
        std::cerr << "其他错误: " << e.what() << "\n";
    }
}
// STL 自带异常：v.at(越界下标) 会扔 out_of_range 信号球

// ─── student.h ─── 说明书（对外公开的"名片夹"）
#ifndef STUDENT_H            // include guard（防重复抄写封条）：已抄过就跳过
#define STUDENT_H
#include <string>

class Student {
public:
    Student(std::string n, int s);
    std::string getName() const;
private:
    std::string name;
    int score;
};
#endif                       // （主流编译器也支持一行版：#pragma once）

// ─── student.cpp ─── 实现
#include "student.h"         // 双引号：从当前目录找（自己的说明书也要抄）

Student::Student(std::string n, int s) : name(n), score(s) {}

std::string Student::getName() const {   // 类外实现：类名:: 前缀
    return name;
}

// ─── main.cpp ─── 使用者
#include "student.h"
#include <iostream>

int main() {
    Student s("Alice", 95);
    std::cout << s.getName() << "\n";
}

// 编译：把所有 .cpp 一起交给编译 + 装配
// g++ main.cpp student.cpp -o app

// 这段代码用到了本教程的：模板、智能指针、lambda、范围for、结构化绑定、多态
// ——外加两个"下一站"概念（移动语义 make_unique 内部、auto 结构化绑定）

#include <vector>
#include <memory>
#include <string>
#include <iostream>

int main() {
    std::vector<std::unique_ptr<std::string>> bag;      // 第六章 + 第八章
    bag.push_back(std::make_unique<std::string>("现代"));  // 第六章
    bag.push_back(std::make_unique<std::string>("C++"));

    int total = 0;
    for (const auto& p : bag) {                          // 第三章 + 第五章
        total += static_cast<int>(p->size());            // 第一章 + 第六章
    }
    std::cout << "总字符数: " << total << "\n";
}
// 如果你能逐行讲出每个语法点出自哪一章——恭喜毕业 🎓