STL容器

// vector 内部逻辑上等价的三个指针
T* _start;          // 指向第一个元素
T* _finish;         // 指向最后一个元素的下一个位置（即 end()）
T* _end_of_storage; // 指向当前分配内存的末尾

#include <iostream>  // 标准输入输出
#include <vector>    // vector 头文件
 
int main() {
    std::vector<int> v;  // 创建一个空的 int 型 vector
 
    for (int i = 0; i < 10; ++i) {
        v.push_back(i);  // 尾部插入元素 i
 
        // 每次插入后打印 size 和 capacity 的变化
        std::cout << "size: " << v.size()        // 实际元素个数
                  << "  capacity: " << v.capacity() // 已分配空间大小
                  << std::endl;
    }
    return 0;
}

#include <vector>  // vector 头文件
 
int main() {
    std::vector<int> v;     // 创建空 vector
    v.reserve(1000);        // 预分配 1000 个 int 的空间，size 仍然为 0
 
    // 此后插入 1000 个元素的过程中不会发生任何扩容
    for (int i = 0; i < 1000; ++i) {
        v.push_back(i);     // 直接写入已分配好的内存，无需 reallocation
    }
    return 0;
}

#include <vector>      // vector 头文件
#include <iostream>    // 标准输入输出
#include <algorithm>   // 标准算法（此处备用）
 
int main() {
    // ========== 1. 默认构造：空 vector ==========
    std::vector<int> v1;                    // size=0, capacity=0
 
    // ========== 2. 指定大小，元素值默认初始化（int 为 0）==========
    std::vector<int> v2(5);                 // {0, 0, 0, 0, 0}
 
    // ========== 3. 指定大小 + 填充值 ==========
    std::vector<int> v3(5, 42);             // {42, 42, 42, 42, 42}
 
    // ========== 4. 初始化列表（C++11 起）==========
    std::vector<int> v4 = {1, 2, 3, 4, 5}; // 直接指定每个元素
 
    // ========== 5. 拷贝构造 ==========
    std::vector<int> v5(v4);                // v5 是 v4 的深拷贝（独立副本）
 
    // ========== 6. 移动构造（C++11 起）==========
    std::vector<int> v6(std::move(v5));     // v5 的资源被"偷走"，v5 变为空
 
    // ========== 7. 范围构造（迭代器区间）==========
    std::vector<int> v7(v4.begin(), v4.begin() + 3);  // {1, 2, 3}，取前 3 个元素
 
    // ========== 8. 从原生数组构造 ==========
    int arr[] = {10, 20, 30};               // C 风格数组
    std::vector<int> v8(arr, arr + 3);      // 利用指针作为迭代器: {10, 20, 30}
 
    return 0;
}

#include <vector>    // vector 头文件
#include <iostream>  // 标准输入输出
 
int main() {
    std::vector<int> v = {10, 20, 30, 40, 50};  // 初始化 5 个元素
 
    // ====== 1. operator[]：下标访问，不做越界检查 ======
    std::cout << v[0] << std::endl;   // 输出 10，最快但不安全
    // v[100]; // ❌ 未定义行为（UB），不会抛异常，可能读到垃圾值甚至 crash
 
    // ====== 2. at()：带边界检查的访问 ======
    std::cout << v.at(2) << std::endl; // 输出 30
    // v.at(100); // ✅ 抛出 std::out_of_range 异常，可被 catch 捕获
 
    // ====== 3. front() / back()：首尾元素 ======
    std::cout << v.front() << std::endl; // 输出 10（等价于 v[0]）
    std::cout << v.back() << std::endl;  // 输出 50（等价于 v[size()-1]）
 
    // ====== 4. data()：获取底层 C 风格数组指针 ======
    int* ptr = v.data();                 // 返回指向内部数组的原始指针
    std::cout << ptr[1] << std::endl;    // 输出 20，可传给 C API
 
    return 0;
}

#include <vector>   // vector 头文件
#include <string>   // string 头文件
#include <iostream>  // 标准输入输出
 
int main() {
    std::vector<std::string> names;  // 空的 string vector
 
    // ====== push_back：先构造临时对象，再拷贝/移动进 vector ======
    std::string s = "Alice";         // 先构造好字符串
    names.push_back(s);              // 拷贝 s 进 vector（s 仍然有效）
    names.push_back("Bob");          // 从字面量构造临时 string，再移动进去
 
    // ====== emplace_back（C++11）：直接在 vector 内存中原地构造 ======
    names.emplace_back("Charlie");   // 直接用 "Charlie" 在尾部原地构造
    // 省去了临时对象的创建和拷贝/移动，对复杂对象更高效
 
    for (const auto& name : names) { // 范围 for 遍历（const 引用避免拷贝）
        std::cout << name << " ";    // 输出: Alice Bob Charlie
    }
    std::cout << std::endl;
 
    return 0;
}

std::vector<int> v = {1, 2, 3};  // 初始化 {1, 2, 3}
v.pop_back();                     // 移除尾部元素，v 变为 {1, 2}
// 注意：pop_back() 不返回被删除的值！如果需要，先用 back() 取出

#include <vector>    // vector 头文件
#include <iostream>  // 标准输入输出
 
int main() {
    std::vector<int> v = {10, 20, 30, 40, 50};  // 初始化
 
    // ====== insert：在指定位置之前插入 ======
    auto it = v.begin() + 2;         // 迭代器指向下标 2 的位置（值 30）
    v.insert(it, 25);                // 在 30 前面插入 25 → {10, 20, 25, 30, 40, 50}
    // ⚠️ insert 之后，it 可能已失效（若发生扩容），不要再使用旧 it
 
    // ====== erase：删除指定位置的元素 ======
    v.erase(v.begin());              // 删除第一个元素 → {20, 25, 30, 40, 50}
 
    // ====== erase 范围：删除一个区间 [first, last) ======
    v.erase(v.begin() + 1, v.begin() + 3); // 删除下标 1~2 → {20, 40, 50}
 
    for (int x : v) {                // 遍历输出
        std::cout << x << " ";       // 输出: 20 40 50
    }
    std::cout << std::endl;
 
    return 0;
}

#include <vector>    // vector 头文件
#include <iostream>  // 标准输入输出
 
int main() {
    std::vector<int> v = {10, 20, 30, 40, 50};  // 初始化
 
    // ====== 正向迭代 ======
    // begin() 指向第一个元素，end() 指向最后一个元素的"下一个位置"（past-the-end）
    for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";     // 解引用 *it 获取元素值
    }
    // 输出: 10 20 30 40 50
    std::cout << std::endl;
 
    // ====== 使用 auto 简化（C++11 起，强烈推荐）======
    for (auto it = v.begin(); it != v.end(); ++it) {
        *it += 100;                  // 通过迭代器修改元素值
    }
    // v 变为 {110, 120, 130, 140, 150}
 
    // ====== 反向迭代 ======
    for (auto rit = v.rbegin(); rit != v.rend(); ++rit) {
        std::cout << *rit << " ";    // 从尾到头遍历
    }
    // 输出: 150 140 130 120 110
    std::cout << std::endl;
 
    // ====== const 迭代器（只读，不可修改元素）======
    for (auto cit = v.cbegin(); cit != v.cend(); ++cit) {
        std::cout << *cit << " ";    // 只能读取，不能写入
        // *cit = 0; // ❌ 编译错误！cbegin() 返回 const_iterator
    }
    std::cout << std::endl;
 
    return 0;
}

// vector v = {10, 20, 30, 40, 50}
//
//  begin()                                     end()
//    |                                           |
//    v                                           v
//  +------+------+------+------+------+--------------------+
//  |  10  |  20  |  30  |  40  |  50  |  past-the-end      |
//  +------+------+------+------+------+--------------------+
//  [0]    [1]    [2]    [3]    [4]       ← 不可解引用!
//
//  rbegin() 指向 50（逻辑上的反向第一个）
//  rend()   指向 10 之前的位置（逻辑上的反向 past-the-end）

#include <vector>    // vector 头文件
#include <iostream>  // 标准输入输出
 
int main() {
    std::vector<int> v = {1, 2, 3, 2, 4, 2, 5};  // 含重复值 2
 
    // ====== ❌ 错误写法：erase 后继续使用旧迭代器 ======
    // for (auto it = v.begin(); it != v.end(); ++it) {
    //     if (*it == 2) {
    //         v.erase(it);  // erase 之后 it 已经失效
    //         // 下一次循环的 ++it 是未定义行为（UB）！
    //     }
    // }
 
    // ====== ✅ 正确写法：利用 erase 的返回值更新迭代器 ======
    for (auto it = v.begin(); it != v.end(); /* 不在这里 ++ */) {
        if (*it == 2) {
            it = v.erase(it);  // erase 返回指向被删元素下一个元素的有效迭代器
        } else {
            ++it;              // 不删除时才手动前进
        }
    }
 
    for (int x : v) {           // 遍历打印结果
        std::cout << x << " ";  // 输出: 1 3 4 5
    }
    std::cout << std::endl;
 
    return 0;
}

#include <vector>     // vector 头文件
#include <algorithm>  // std::remove 算法
#include <iostream>   // 标准输入输出
 
int main() {
    std::vector<int> v = {1, 2, 3, 2, 4, 2, 5};  // 含重复值 2
 
    // std::remove 把所有不等于 2 的元素移到前面，返回"新逻辑末尾"的迭代器
    // erase 从该位置到 end() 删除剩余的"垃圾"元素
    v.erase(std::remove(v.begin(), v.end(), 2), v.end());
 
    for (int x : v) {           // 遍历打印
        std::cout << x << " ";  // 输出: 1 3 4 5
    }
    std::cout << std::endl;
 
    // C++20 更简洁：std::erase(v, 2); 一步到位
    return 0;
}

#include <vector>    // vector 头文件
#include <iostream>  // 标准输入输出
 
int main() {
    int rows = 3, cols = 4;   // 3 行 4 列
 
    // 构造 3x4 的二维 vector，所有元素初始化为 0
    std::vector<std::vector<int>> matrix(rows, std::vector<int>(cols, 0));
    //          外层 vector 有 rows 个元素，每个元素是 vector<int>(cols, 0)
 
    matrix[1][2] = 42;        // 访问第 2 行第 3 列，赋值 42
 
    // 嵌套范围 for 遍历
    for (const auto& row : matrix) {      // row 是 const vector<int>&
        for (int val : row) {             // val 是 int（拷贝，因为 int 很小）
            std::cout << val << "\t";     // tab 分隔
        }
        std::cout << std::endl;
    }
    return 0;
}

#include <vector>    // vector 头文件
#include <iostream>  // 标准输入输出
 
int main() {
    std::vector<int> v(10000, 1);  // 分配 10000 个元素
 
    v.clear();                     // size=0，但 capacity 仍然 >= 10000
    std::cout << "After clear - capacity: " << v.capacity() << std::endl;
 
    // ====== 方法一：swap 技巧（C++11 之前的经典做法）======
    std::vector<int>().swap(v);    // 用一个空 vector 与 v 交换，v 的内存被释放
    std::cout << "After swap  - capacity: " << v.capacity() << std::endl; // 0
 
    // ====== 方法二：shrink_to_fit()（C++11 起，更直观但不保证）======
    v.assign(10000, 1);            // 重新填充
    v.clear();                     // size=0
    v.shrink_to_fit();             // 请求释放多余内存（实现可以忽略此请求）
    std::cout << "After shrink - capacity: " << v.capacity() << std::endl;
 
    return 0;
}

#include <vector>
#include <iostream>
 
int main() {
    std::vector<int> v;
    v.reserve(10);
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
 
    std::cout << v.size() << " " << v.capacity() << std::endl;
    
    v.resize(6);
    std::cout << v.size() << " " << v.capacity() << std::endl;
    
    v.shrink_to_fit();
    std::cout << v.size() << " " << v.capacity() << std::endl;
 
    return 0;
}

std::vector<int> v = {1, 2, 3, 4, 5};
auto it = v.begin() + 2;  // 指向元素 3
v.push_back(6);
std::cout << *it << std::endl;

#include <string>  // 必须包含此头文件
#include <iostream>
using namespace std;
 
int main() {
    // ========== 1. 默认构造：创建空字符串 ==========
    string s1;                        // s1 = ""，长度为0
 
    // ========== 2. 从 C 风格字符串（const char*）构造 ==========
    string s2("Hello, C++");          // 直接用字面量初始化
    string s2b = "Hello, C++";        // 等价写法（拷贝初始化）
 
    // ========== 3. 拷贝构造：从另一个 string 复制 ==========
    string s3(s2);                    // s3 是 s2 的完整副本（深拷贝）
    string s3b = s2;                  // 等价写法
 
    // ========== 4. 移动构造（C++11）：窃取临时对象的资源 ==========
    string s4(std::move(s1));         // s4 接管 s1 的内部缓冲区，s1 变为空
 
    // ========== 5. 填充构造：用 n 个相同字符填充 ==========
    string s5(10, '*');               // s5 = "**********"（10个星号）
 
    // ========== 6. 子串构造：从已有字符串截取一段 ==========
    string s6(s2, 7, 3);             // 从 s2 的第7个字符起，取3个字符 → "C++"
    // 参数：(源字符串, 起始位置, 截取长度)
    // 如果省略第三个参数，则截取到末尾
 
    // ========== 7. 迭代器范围构造 ==========
    string s7(s2.begin(), s2.begin() + 5);  // 取 s2 前5个字符 → "Hello"
 
    // ========== 8. 初始化列表构造（C++11） ==========
    string s8{'H', 'i', '!'};        // s8 = "Hi!"
 
    // 输出验证
    cout << "s2: " << s2 << endl;     // Hello, C++
    cout << "s5: " << s5 << endl;     // **********
    cout << "s6: " << s6 << endl;     // C++
    cout << "s7: " << s7 << endl;     // Hello
 
    return 0;
}

#include <string>
#include <iostream>
using namespace std;
 
int main() {
    string s = "Hello";
 
    // ========== 基本大小查询 ==========
    cout << s.size()     << endl;  // 5  —— 字符个数
    cout << s.length()   << endl;  // 5  —— 与 size() 完全等价
    cout << s.capacity() << endl;  // >= 5，通常为 15（SSO）或更大
    cout << s.empty()    << endl;  // 0 (false)，非空
    cout << s.max_size() << endl;  // 理论最大长度，通常为一个极大的值
 
    // ========== 主动管理容量 ==========
    s.reserve(100);                // 预分配至少100字符的空间（不改变内容）
    cout << s.capacity() << endl;  // >= 100
    cout << s.size()     << endl;  // 仍然是 5，内容未变
 
    s.shrink_to_fit();             // 请求释放多余内存（C++11，非强制）
    cout << s.capacity() << endl;  // 可能回落到接近 size() 的值
 
    // ========== 调整大小 ==========
    s.resize(10, '!');             // 扩展到10个字符，新位置用 '!' 填充
    cout << s << endl;             // "Hello!!!!!"
    cout << s.size() << endl;      // 10
 
    s.resize(3);                   // 截断到3个字符
    cout << s << endl;             // "Hel"
 
    return 0;
}

#include <string>
#include <iostream>
#include <stdexcept>
using namespace std;
 
int main() {
    string s = "ABCDEF";
 
    // ========== operator[] —— 无边界检查，极致性能 ==========
    cout << s[0] << endl;          // 'A' —— 第一个字符
    cout << s[5] << endl;          // 'F' —— 最后一个字符
    s[0] = 'Z';                    // 可以直接修改：s 变为 "ZBCDEF"
    // s[100] → 未定义行为！不会抛异常，可能读到垃圾值或直接崩溃
 
    // ========== at() —— 有边界检查，更安全 ==========
    cout << s.at(1) << endl;       // 'B'
    try {
        cout << s.at(100) << endl; // 越界！抛出 std::out_of_range 异常
    } catch (const out_of_range& e) {
        cout << "越界异常: " << e.what() << endl;  // 会执行到这里
    }
 
    // ========== front() / back() —— 快捷访问首尾 ==========
    cout << s.front() << endl;     // 'Z' —— 等价于 s[0]
    cout << s.back()  << endl;     // 'F' —— 等价于 s[s.size()-1]
 
    // ========== c_str() / data() —— 获取底层 C 字符串 ==========
    const char* p = s.c_str();     // 返回以 '\0' 结尾的 const char*
    cout << p << endl;             // "ZBCDEF"
    // 常用于与 C 库函数（如 fopen, printf）交互
 
    return 0;
}

#include <string>
#include <iostream>
using namespace std;
 
int main() {
    // ============================================
    //  1. 追加（Append）—— 在末尾添加内容
    // ============================================
    string s = "Hello";
    s += " World";                 // 运算符重载，最直观的追加方式
    s.append("!!!");               // 等价方式，函数调用
    s.append(3, '?');              // 追加3个 '?' → "Hello World!!!???"
    s.push_back('~');              // 追加单个字符 → "Hello World!!!???~"
    cout << s << endl;
 
    // ============================================
    //  2. 插入（Insert）—— 在任意位置插入内容
    // ============================================
    string t = "HelloWorld";
    t.insert(5, ", ");             // 在位置5插入 ", " → "Hello, World"
    t.insert(0, ">> ");            // 在开头插入 → ">> Hello, World"
    t.insert(t.end(), '!');        // 用迭代器在末尾插入 → ">> Hello, World!"
    cout << t << endl;
 
    // ============================================
    //  3. 删除（Erase）—— 移除字符
    // ============================================
    string u = "ABCDEFGH";
    u.erase(2, 3);                 // 从位置2开始，删除3个字符 → "ABFGH"
    u.erase(u.begin());            // 删除第一个字符 → "BFGH"
    u.erase(u.end() - 1);         // 删除最后一个字符 → "BFG"
    cout << u << endl;
 
    // ============================================
    //  4. 替换（Replace）—— 用新内容替换一段区间
    // ============================================
    string v = "I love Java";
    v.replace(7, 4, "C++");        // 从位置7起，将4个字符替换为 "C++"
    cout << v << endl;             // "I love C++"
    // 注意：替换内容长度可以不等于被替换长度，string 会自动调整
 
    // ============================================
    //  5. 清空（Clear）与赋值（Assign）
    // ============================================
    string w = "temporary";
    w.clear();                     // 清空内容，size 变为 0，但 capacity 不变
    cout << w.empty() << endl;     // 1 (true)
 
    w.assign("New Content");       // 重新赋值
    w = "Also Works";              // 赋值运算符，等价方式
    cout << w << endl;
 
    return 0;
}

// 高性能字符串拼接的最佳实践
string build_greeting(const string& name, int age) {
    string result;
    result.reserve(50);             // 预估总长度，一次性分配
    result.append("Hello, ");       // 无需重新分配
    result.append(name);            // 无需重新分配
    result.append("! You are ");    // 无需重新分配
    result.append(to_string(age));  // to_string 将 int 转为 string
    result.append(" years old.");   // 无需重新分配
    return result;                  // RVO/NRVO 优化，通常无拷贝
}

#include <string>
#include <iostream>
using namespace std;
 
int main() {
    string text = "C++ is powerful. C++ is fast. C++ is everywhere.";
 
    // ========== find —— 从左向右查找第一次出现的位置 ==========
    size_t pos1 = text.find("C++");          // 返回 0（第一个 "C++" 在位置0）
    size_t pos2 = text.find("C++", 1);       // 从位置1开始找 → 返回 17
    size_t pos3 = text.find("Rust");         // 没找到 → 返回 string::npos
    cout << pos1 << ", " << pos2 << endl;    // 0, 17
 
    // 判断是否找到的标准写法
    if (text.find("Rust") == string::npos) {
        cout << "未找到 Rust" << endl;        // 会执行到这里
    }
 
    // ========== rfind —— 从右向左查找（最后一次出现） ==========
    size_t last = text.rfind("C++");         // 返回 30（最后一个 "C++"）
    cout << "最后出现位置: " << last << endl;
 
    // ========== find_first_of / find_last_of —— 查找字符集合中的任意字符 ==========
    string vowels = "aeiou";
    size_t v1 = text.find_first_of(vowels);  // 找到第一个元音字母的位置
    size_t v2 = text.find_last_of(vowels);   // 找到最后一个元音字母的位置
    cout << "第一个元音在位置: " << v1 << endl;
 
    // ========== find_first_not_of —— 查找第一个 不在 集合中的字符 ==========
    string digits = "0123456789";
    string mixed = "123abc456";
    size_t non_digit = mixed.find_first_not_of(digits);  // 返回 3（'a' 的位置）
    cout << "第一个非数字在位置: " << non_digit << endl;
 
    return 0;
}

#include <string>
#include <iostream>
using namespace std;
 
int main() {
    string s = "Hello, World!";
 
    // ========== substr —— 提取子串 ==========
    string sub1 = s.substr(7);       // 从位置7到末尾 → "World!"
    string sub2 = s.substr(0, 5);    // 从位置0取5个字符 → "Hello"
    cout << sub1 << endl;
    cout << sub2 << endl;
 
    // ========== compare —— 字典序比较 ==========
    string a = "apple";
    string b = "banana";
    int cmp = a.compare(b);         // < 0，因为 "apple" < "banana"
    // 返回值：< 0 表示 a 在 b 前面，0 表示相等，> 0 表示 a 在 b 后面
 
    // 更常用的方式：直接使用关系运算符
    if (a == b) cout << "相等" << endl;
    if (a != b) cout << "不等" << endl;     // ✓ 会执行
    if (a < b)  cout << "a 更小" << endl;   // ✓ 会执行（字典序）
    // ==, !=, <, >, <=, >= 全部支持，且可与 const char* 混用
 
    // ========== starts_with / ends_with（C++20） ==========
    string url = "https://www.example.com";
    // C++20 新增，非常实用
    // cout << url.starts_with("https") << endl;  // 1 (true)
    // cout << url.ends_with(".com")    << endl;   // 1 (true)
 
    // C++20 之前的替代方案
    bool starts = (url.find("https") == 0);               // 判断前缀
    bool ends   = (url.rfind(".com") == url.size() - 4);   // 判断后缀
    cout << starts << ", " << ends << endl;                // 1, 1
 
    return 0;
}

#include <string>
#include <iostream>
using namespace std;
 
int main() {
    // ========== string → 数值 ==========
    string s1 = "42";
    string s2 = "3.14159";
    string s3 = "0xFF";
 
    int    n1 = stoi(s1);           // string to int → 42
    long   n2 = stol(s1);           // string to long
    float  f1 = stof(s2);           // string to float → 3.14159
    double d1 = stod(s2);           // string to double
    int    n3 = stoi(s3, nullptr, 16);  // 十六进制转换 → 255
    // stoi 第三个参数指定进制：0(自动检测), 2, 8, 10, 16 等
 
    cout << n1 << ", " << d1 << ", " << n3 << endl;
 
    // 如果转换失败会抛异常
    try {
        int bad = stoi("not_a_number"); // 抛出 std::invalid_argument
    } catch (const invalid_argument& e) {
        cout << "转换失败: " << e.what() << endl;
    }
 
    try {
        int overflow = stoi("99999999999999999"); // 抛出 std::out_of_range
    } catch (const out_of_range& e) {
        cout << "数值溢出: " << e.what() << endl;
    }
 
    // ========== 数值 → string ==========
    string from_int    = to_string(42);        // "42"
    string from_double = to_string(3.14);      // "3.140000"（注意精度）
    string from_bool   = to_string(true);      // "1"
 
    cout << from_int << ", " << from_double << endl;
 
    return 0;
}

#include <string>
#include <algorithm>  // sort, reverse, transform, ...
#include <iostream>
#include <cctype>     // toupper, tolower, isdigit, isalpha ...
using namespace std;
 
int main() {
    // ========== 1. 排序 ==========
    string s = "dcba";
    sort(s.begin(), s.end());       // 按 ASCII 升序排列
    cout << s << endl;              // "abcd"
 
    // ========== 2. 反转 ==========
    string r = "Hello";
    reverse(r.begin(), r.end());    // 原地反转
    cout << r << endl;              // "olleH"
 
    // ========== 3. 大小写转换 ==========
    string text = "Hello, World!";
    // transform 对每个字符应用函数并写回
    transform(text.begin(), text.end(),  // 输入范围
              text.begin(),              // 输出起始位置（原地修改）
              ::toupper);                // 对每个 char 调用 toupper
    cout << text << endl;                // "HELLO, WORLD!"
 
    transform(text.begin(), text.end(), text.begin(), ::tolower);
    cout << text << endl;                // "hello, world!"
 
    // ========== 4. 统计字符出现次数 ==========
    string data = "abracadabra";
    int cnt = count(data.begin(), data.end(), 'a');  // 统计 'a' 的个数
    cout << "'a' 出现了 " << cnt << " 次" << endl;   // 5 次
 
    // ========== 5. 判断是否全是数字 ==========
    string num = "12345";
    bool all_digits = all_of(num.begin(), num.end(),
                             [](char c) { return isdigit(c); });
    cout << "全是数字: " << all_digits << endl;       // 1 (true)
 
    // ========== 6. 去除空白（Trim）—— 标准库无内置，手动实现 ==========
    string padded = "   Hello   ";
    // 去除前导空白
    size_t start = padded.find_first_not_of(" \t\n\r");
    // 去除尾部空白
    size_t end   = padded.find_last_not_of(" \t\n\r");
    // 提取中间内容
    string trimmed = (start == string::npos) ? "" : padded.substr(start, end - start + 1);
    cout << "[" << trimmed << "]" << endl;            // "[Hello]"
 
    return 0;
}

#include <string>
#include <cstring>   // strlen, strcmp 等 C 函数
#include <cstdio>    // printf, snprintf
#include <iostream>
using namespace std;
 
int main() {
    // ========== string → const char* ==========
    string cpp_str = "Hello from C++";
    const char* c_str = cpp_str.c_str();   // 返回 '\0' 结尾的 C 字符串
    printf("C 风格输出: %s\n", c_str);      // 传给 C 函数
 
    // ⚠️ 注意：c_str() 返回的指针在 string 被修改/销毁后失效！
    // const char* dangling = cpp_str.c_str();
    // cpp_str += " modified";  // 可能触发重新分配
    // printf("%s\n", dangling); // 未定义行为！dangling 可能已经指向被释放的内存
 
    // ========== const char* → string ==========
    const char* raw = "Hello from C";
    string from_c(raw);                     // 隐式构造
    string from_c2 = raw;                   // 等价写法
 
    // ========== 与 C 函数混用 ==========
    cout << "长度: " << strlen(cpp_str.c_str()) << endl;   // C 方式取长度
    cout << "长度: " << cpp_str.size()          << endl;    // C++ 方式（推荐）
 
    return 0;
}

#include <string>
#include <string_view>  // C++17
#include <iostream>
using namespace std;
 
// 使用 string_view 作为参数类型 —— 同时接受 string 和 const char*
void print_info(string_view sv) {
    // string_view 支持大部分 string 的只读操作
    cout << "内容: " << sv << endl;
    cout << "长度: " << sv.size() << endl;
    cout << "前3字符: " << sv.substr(0, 3) << endl;  // 返回 string_view，零拷贝！
}
 
int main() {
    string str = "Hello, string_view!";
    const char* cstr = "Hello, C string!";
 
    print_info(str);     // 从 string 隐式构造 string_view（零拷贝）
    print_info(cstr);    // 从 const char* 隐式构造 string_view（零拷贝）
    print_info("literal"); // 从字面量构造（零拷贝）
 
    // ⚠️ 危险用法 —— string_view 不拥有数据，原始数据销毁后 view 悬空
    // string_view dangling;
    // {
    //     string temp = "temporary";
    //     dangling = temp;          // dangling 指向 temp 的内部缓冲区
    // }  // temp 析构，缓冲区被释放
    // cout << dangling << endl;     // 未定义行为！悬空引用
 
    return 0;
}

#include <string>
#include <iostream>
#include <sstream>   // istringstream, ostringstream
using namespace std;
 
int main() {
    // ========== getline —— 读取完整一行 ==========
    string line;
    cout << "请输入一行文字: ";
    getline(cin, line);              // 读取到换行符为止（换行符被丢弃）
    cout << "你输入了: " << line << endl;
 
    // 自定义分隔符（例如用逗号分隔）
    // getline(cin, line, ',');      // 读取到逗号为止
 
    // ========== istringstream —— 字符串流分割 ==========
    string csv = "Alice,Bob,Charlie,Diana";
    istringstream iss(csv);          // 将字符串包装为输入流
    string token;
    while (getline(iss, token, ',')) {  // 以逗号为分隔符逐段读取
        cout << "姓名: " << token << endl;
    }
    // 输出：
    // 姓名: Alice
    // 姓名: Bob
    // 姓名: Charlie
    // 姓名: Diana
 
    // ========== ostringstream —— 格式化拼接 ==========
    ostringstream oss;
    oss << "Pi = " << 3.14159 << ", e = " << 2.71828;
    string result = oss.str();       // 提取拼接结果
    cout << result << endl;          // "Pi = 3.14159, e = 2.71828"
 
    return 0;
}

#include <string>
#include <iostream>
using namespace std;
 
int main() {
    string s = "Hello, World!";
    s.erase(5, 7);
    s.insert(5, " C++");
    cout << s << endl;
    return 0;
}

// 一个最简单的键值对示例
#include <map>
#include <string>
#include <iostream>
 
int main() {
    // 创建一个 map，Key 是 string，Value 是 int
    std::map<std::string, int> ages;
 
    // 插入键值对：学生姓名 -> 年龄
    ages["Alice"] = 25;       // 使用 operator[] 插入
    ages["Bob"]   = 30;       // Key="Bob", Value=30
    ages["Carol"] = 28;       // Key="Carol", Value=28
 
    // 通过 Key 检索 Value
    std::cout << "Bob's age: " << ages["Bob"] << std::endl; // 输出 30
 
    return 0;
}

#include <map>
#include <string>
 
int main() {
    // 1. 默认构造：空 map
    std::map<std::string, int> m1;
 
    // 2. 初始化列表构造 (C++11)
    std::map<std::string, int> m2 = {
        {"apple",  3},   // Key="apple",  Value=3
        {"banana", 5},   // Key="banana", Value=5
        {"cherry", 2}    // Key="cherry", Value=2
    };
 
    // 3. 拷贝构造
    std::map<std::string, int> m3(m2);  // m3 是 m2 的深拷贝
 
    // 4. 范围构造：从另一个容器的迭代器区间构造
    std::map<std::string, int> m4(m2.begin(), m2.end());
 
    // 5. 自定义排序：使用 std::greater 让 Key 降序排列
    std::map<std::string, int, std::greater<std::string>> m5 = {
        {"apple",  3},
        {"banana", 5},
        {"cherry", 2}
    };
    // m5 遍历顺序: cherry -> banana -> apple（降序）
 
    return 0;
}

#include <map>
#include <string>
#include <iostream>
 
int main() {
    std::map<std::string, int> scores;
 
    // ========== 方式1: operator[] ==========
    // 若 Key 不存在 -> 插入新键值对，Value 被值初始化（int 为 0），然后赋值
    // 若 Key 已存在 -> 直接返回已有 Value 的引用，执行赋值（覆盖）
    scores["Alice"] = 90;    // 插入 {"Alice", 90}
    scores["Alice"] = 95;    // Key 已存在，覆盖为 95
 
    // ⚠️ 陷阱：仅读取时 operator[] 也会插入！
    int val = scores["Ghost"]; // "Ghost" 不存在，但会被插入，val = 0
    // 此时 scores 已包含 {"Ghost", 0}！
 
    // ========== 方式2: insert ==========
    // 若 Key 不存在 -> 插入成功，返回 {iterator, true}
    // 若 Key 已存在 -> 插入失败（不覆盖），返回 {iterator, false}
    auto [it1, ok1] = scores.insert({"Bob", 88});       // 插入成功, ok1=true
    auto [it2, ok2] = scores.insert({"Alice", 100});     // 失败! Alice 已存在, ok2=false
    // Alice 的值仍是 95，不会被 100 覆盖
 
    // ========== 方式3: emplace (C++11) ==========
    // 原地构造，避免临时对象的拷贝，语义与 insert 相同（不覆盖）
    auto [it3, ok3] = scores.emplace("Carol", 77);       // 原地构造并插入
 
    // ========== 方式4: insert_or_assign (C++17) ==========
    // 若 Key 不存在 -> 插入，返回 {iterator, true}
    // 若 Key 已存在 -> 覆盖 Value，返回 {iterator, false}
    auto [it4, ok4] = scores.insert_or_assign("Alice", 100); // Alice 被覆盖为 100
    // 这是 operator[] 赋值的"安全替代品"
 
    // ========== 方式5: try_emplace (C++17) ==========
    // 若 Key 不存在 -> 原地构造并插入
    // 若 Key 已存在 -> 什么都不做（参数甚至不会被 move）
    scores.try_emplace("Dave", 66);   // Dave 不存在，插入成功
    scores.try_emplace("Alice", 0);   // Alice 已存在，什么都不发生
 
    return 0;
}

#include <map>
#include <string>
#include <iostream>
 
int main() {
    std::map<std::string, int> m = {
        {"Alice", 90}, {"Bob", 85}, {"Carol", 77}
    };
 
    // ========== 方式1: find ==========
    // 返回迭代器，找不到返回 end()
    auto it = m.find("Bob");              // 在红黑树中 O(log n) 搜索
    if (it != m.end()) {                  // 判断是否找到
        // it->first 是 Key，it->second 是 Value
        std::cout << it->first << ": " << it->second << std::endl;
    }
 
    // ========== 方式2: count ==========
    // 对于 map，Key 唯一，count 只会返回 0 或 1
    if (m.count("Dave") == 0) {           // O(log n)
        std::cout << "Dave not found" << std::endl;
    }
 
    // ========== 方式3: contains (C++20) ==========
    // 语义最清晰的存在性检查
    if (m.contains("Alice")) {            // O(log n)，返回 bool
        std::cout << "Alice exists!" << std::endl;
    }
 
    // ========== 方式4: at() ==========
    // 安全访问：Key 不存在时抛出 std::out_of_range 异常
    try {
        int score = m.at("Ghost");        // Ghost 不存在，抛异常
    } catch (const std::out_of_range& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }
 
    return 0;
}

#include <map>
#include <string>
#include <iostream>
 
int main() {
    std::map<std::string, int> m = {
        {"cherry", 2}, {"apple", 3}, {"banana", 5}
    };
    // 注意：内部已按 Key 排序 -> apple, banana, cherry
 
    // ========== 方式1: 范围 for + 结构化绑定 (C++17, 推荐) ==========
    for (const auto& [key, value] : m) {  // 自动解包为 key 和 value
        std::cout << key << " => " << value << std::endl;
    }
    // 输出：apple => 3, banana => 5, cherry => 2（有序！）
 
    // ========== 方式2: 范围 for + pair ==========
    for (const auto& pair : m) {          // pair 类型是 std::pair<const string, int>
        std::cout << pair.first << " => " << pair.second << std::endl;
    }
 
    // ========== 方式3: 迭代器 ==========
    for (auto it = m.begin(); it != m.end(); ++it) {
        std::cout << it->first << " => " << it->second << std::endl;
    }
 
    // ========== 方式4: 反向遍历 ==========
    for (auto rit = m.rbegin(); rit != m.rend(); ++rit) {
        std::cout << rit->first << " => " << rit->second << std::endl;
    }
    // 输出：cherry => 2, banana => 5, apple => 3（降序）
 
    return 0;
}

#include <map>
#include <string>
#include <iostream>
 
int main() {
    std::map<std::string, int> m = {
        {"Alice", 90}, {"Bob", 85}, {"Carol", 77}, {"Dave", 66}
    };
 
    // 1. 按 Key 删除，返回删除的元素个数（0 或 1）
    size_t removed = m.erase("Bob");      // removed = 1
    m.erase("Ghost");                     // Key 不存在，removed = 0，不会报错
 
    // 2. 按迭代器删除
    auto it = m.find("Carol");            // 先查找
    if (it != m.end()) {
        m.erase(it);                      // 删除迭代器指向的元素
    }
 
    // 3. 范围删除：删除 [first, last) 区间
    m.erase(m.begin(), m.end());          // 等价于 m.clear()
 
    return 0;
}

#include <map>
#include <string>
#include <iostream>
 
// 自定义比较器：按字符串长度排序，长度相同按字典序
struct LengthCompare {
    bool operator()(const std::string& a, const std::string& b) const {
        if (a.length() != b.length())     // 先比长度
            return a.length() < b.length();
        return a < b;                     // 长度相同，按字典序
    }
};
 
int main() {
    // 使用自定义比较器
    std::map<std::string, int, LengthCompare> m;
    m["hi"]      = 1;   // 长度 2
    m["hello"]   = 2;   // 长度 5
    m["hey"]     = 3;   // 长度 3
    m["world"]   = 4;   // 长度 5（与 hello 同长度，按字典序排在后面）
 
    for (const auto& [k, v] : m) {
        std::cout << k << "(" << k.length() << ") => " << v << std::endl;
    }
    // 输出: hi(2), hey(3), hello(5), world(5)
 
    return 0;
}

#include <unordered_map>
#include <string>
#include <iostream>
 
int main() {
    // 初始化列表构造
    std::unordered_map<std::string, int> um = {
        {"cherry", 2}, {"apple", 3}, {"banana", 5}
    };
 
    // 插入（与 map 完全相同的接口）
    um["date"] = 7;                                 // operator[]
    um.insert({"elderberry", 1});                   // insert
    um.emplace("fig", 4);                           // emplace
 
    // 查找（与 map 完全相同的接口）
    auto it = um.find("apple");                     // 返回迭代器
    if (it != um.end()) {
        std::cout << it->second << std::endl;       // 输出 3
    }
 
    // 遍历（顺序不确定！）
    for (const auto& [key, value] : um) {
        std::cout << key << " => " << value << std::endl;
    }
    // 输出顺序可能每次运行都不同！
 
    // 删除
    um.erase("banana");                             // 按 Key 删除
 
    return 0;
}

#include <unordered_map>
#include <string>
#include <iostream>
 
int main() {
    std::unordered_map<std::string, int> um;
 
    // 预分配桶数量，减少 rehash 次数（性能优化的关键）
    um.reserve(1000);                // 预留至少能容纳 1000 个元素的桶
 
    // 插入一些数据
    for (int i = 0; i < 500; ++i) {
        um["key_" + std::to_string(i)] = i;
    }
 
    // ========== 哈希表状态查询 ==========
    std::cout << "元素数量:      " << um.size()             << std::endl;
    std::cout << "桶的数量:      " << um.bucket_count()     << std::endl;
    std::cout << "当前负载因子:   " << um.load_factor()      << std::endl;
    std::cout << "最大负载因子:   " << um.max_load_factor()  << std::endl;
 
    // 查看某个 Key 在哪个桶
    size_t bucket_idx = um.bucket("key_42");        // 返回桶的索引
    std::cout << "key_42 在桶 #" << bucket_idx << std::endl;
    std::cout << "该桶元素数量: " << um.bucket_size(bucket_idx) << std::endl;
 
    // 手动 rehash
    um.rehash(2000);               // 将桶数量调整为至少 2000
    std::cout << "rehash 后桶数: " << um.bucket_count() << std::endl;
 
    return 0;
}

#include <unordered_map>
#include <string>
#include <iostream>
#include <functional>    // std::hash
 
// 自定义类型
struct Point {
    int x, y;            // 二维坐标
 
    // 必须提供 operator==，用于桶内链表的精确匹配
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};
 
// 方式1：特化 std::hash（推荐，最通用）
namespace std {
    template<>
    struct hash<Point> {
        size_t operator()(const Point& p) const {
            // 经典的哈希组合公式：将两个字段的哈希值混合
            size_t h1 = std::hash<int>{}(p.x);   // 对 x 计算哈希
            size_t h2 = std::hash<int>{}(p.y);   // 对 y 计算哈希
            // 使用异或 + 位移来混合（Boost 推荐的做法）
            return h1 ^ (h2 << 1);
        }
    };
}
 
int main() {
    // 特化 std::hash 后可以直接使用，无需额外模板参数
    std::unordered_map<Point, std::string> points;
    points[{1, 2}] = "A";           // Point{1,2} -> "A"
    points[{3, 4}] = "B";           // Point{3,4} -> "B"
 
    // 方式2：使用 Lambda 作为哈希函数（局部使用时方便）
    auto hasher = [](const Point& p) -> size_t {
        return std::hash<int>{}(p.x) ^ (std::hash<int>{}(p.y) << 1);
    };
    auto equal = [](const Point& a, const Point& b) -> bool {
        return a.x == b.x && a.y == b.y;
    };
 
    // 模板参数需要指定哈希和相等比较的类型
    std::unordered_map<Point, std::string,
                       decltype(hasher), decltype(equal)> points2(10, hasher, equal);
    //                                                     ^初始桶数
 
    points2[{5, 6}] = "C";
    std::cout << points2[{5, 6}] << std::endl;   // 输出 "C"
 
    return 0;
}

#include <map>
#include <unordered_map>
#include <iostream>
 
int main() {
    // ========== map 的迭代器稳定性 ==========
    std::map<int, int> m = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}};
 
    auto it_map = m.find(3);          // 指向 {3, 3}
    m.erase(2);                       // 删除 {2,2}，it_map 仍然有效！
    m.insert({6, 6});                 // 插入新元素，it_map 仍然有效！
    std::cout << it_map->second;      // 安全输出 3
 
    // 只有删除迭代器自身指向的元素才会使其失效
    m.erase(it_map);                  // it_map 现在失效了！
 
    // ========== unordered_map 的迭代器稳定性 ==========
    std::unordered_map<int, int> um = {{1,1}, {2,2}, {3,3}};
 
    auto it_um = um.find(2);          // 指向 {2, 2}
    // 如果插入操作触发了 rehash，则 it_um 可能失效！
    um.reserve(10000);                // 强制 rehash -> 所有迭代器失效
    // it_um 现在是悬空的(dangling)，使用它是未定义行为(UB)！
 
    return 0;
}

// 安全的遍历删除模式（两种容器通用）
#include <map>
#include <iostream>
 
int main() {
    std::map<int, int> m = {{1,10}, {2,20}, {3,30}, {4,40}, {5,50}};
 
    // 删除所有 Value 为偶数十位的元素
    for (auto it = m.begin(); it != m.end(); /* 不在这里 ++ */) {
        if (it->second % 20 == 0) {       // 满足删除条件
            it = m.erase(it);             // erase 返回下一个有效迭代器
        } else {
            ++it;                         // 不删除时才手动前进
        }
    }
    // 或使用 C++20 的 std::erase_if
    // std::erase_if(m, [](const auto& p){ return p.second % 20 == 0; });
 
    for (const auto& [k, v] : m) {
        std::cout << k << " => " << v << std::endl;
    }
    return 0;
}

#include <map>
#include <iostream>
 
int main() {
    std::map<int, std::string> students = {
        {60, "Dave"}, {70, "Carol"}, {80, "Bob"},
        {85, "Eve"},  {90, "Alice"}, {95, "Frank"}
    };
 
    // lower_bound(key): 返回第一个 >= key 的迭代器
    auto lo = students.lower_bound(75);   // 指向 {80, "Bob"}
 
    // upper_bound(key): 返回第一个 > key 的迭代器
    auto hi = students.upper_bound(90);   // 指向 {95, "Frank"}
 
    // 遍历分数在 [75, 90] 区间内的学生
    std::cout << "Scores in [75, 90]:" << std::endl;
    for (auto it = lo; it != hi; ++it) {  // [lower_bound, upper_bound)
        std::cout << it->first << ": " << it->second << std::endl;
    }
    // 输出: 80:Bob, 85:Eve, 90:Alice
 
    // equal_range(key): 返回 {lower_bound, upper_bound} 的 pair
    auto [eq_lo, eq_hi] = students.equal_range(85);
    // eq_lo 指向 {85, "Eve"}，eq_hi 指向 {90, "Alice"}
 
    return 0;
}

#include <map>
#include <unordered_map>
#include <string>
#include <iostream>
 
int main() {
    // multimap: 有序 + 允许重复 Key
    std::multimap<std::string, int> mm;
    mm.insert({"Alice", 90});     // 第一个 Alice
    mm.insert({"Alice", 95});     // 第二个 Alice（允许！）
    mm.insert({"Bob",   85});
 
    // count 可能返回 > 1
    std::cout << "Alice count: " << mm.count("Alice") << std::endl; // 2
 
    // equal_range 获取同一 Key 的所有元素
    auto [lo, hi] = mm.equal_range("Alice");
    for (auto it = lo; it != hi; ++it) {
        std::cout << it->first << " => " << it->second << std::endl;
    }
    // 输出：Alice => 90, Alice => 95
 
    // ⚠️ multimap 没有 operator[]！（因为一个 Key 对应多个 Value，返回哪个？）
 
    // unordered_multimap: 无序 + 允许重复 Key
    std::unordered_multimap<std::string, int> umm;
    umm.insert({"X", 1});
    umm.insert({"X", 2});
    umm.insert({"X", 3});
    std::cout << "X count: " << umm.count("X") << std::endl; // 3
 
    return 0;
}

#include <unordered_map>
#include <string>
#include <sstream>
#include <iostream>
 
int main() {
    std::string text = "the quick brown fox jumps over the lazy dog the fox";
 
    std::unordered_map<std::string, int> freq;   // 单词 -> 出现次数
    std::istringstream iss(text);                 // 字符串流，用于分词
    std::string word;
 
    while (iss >> word) {          // 按空格分词
        freq[word]++;              // 关键技巧：operator[] 对不存在的 Key 值初始化为 0
    }                              // 然后 ++ 变为 1，后续再 ++ 递增
 
    for (const auto& [w, c] : freq) {
        std::cout << w << ": " << c << std::endl;
    }
    // the: 3, fox: 2, quick: 1, ...
 
    return 0;
}

// ✅ DO: 用 reserve 预分配，减少 rehash
std::unordered_map<int, int> um;
um.reserve(expected_size);           // 预先分配足够的桶
 
// ✅ DO: 用 find 而非 operator[] 做只读查询
if (auto it = um.find(key); it != um.end()) {  // C++17 init-statement
    use(it->second);                 // 不会产生副作用插入
}
 
// ✅ DO: 用 emplace / try_emplace 避免不必要的对象拷贝
um.try_emplace(key, expensive_arg1, expensive_arg2);
 
// ✅ DO: 需要有序或范围查询时用 map
std::map<int, std::string> ordered_data;
auto it = ordered_data.lower_bound(100);  // 高效范围查询
 
// ❌ DON'T: 用 operator[] 做存在性检查
// if (um[key] == 0)  // 错！即使 key 不存在也会被插入
 
// ❌ DON'T: 在遍历中直接删除而不更新迭代器
// for (auto it = m.begin(); it != m.end(); ++it)
//     if (cond) m.erase(it);  // UB! 应使用 it = m.erase(it)

std::map<std::string, int> m;
m["A"] = 1;
m.insert({"B", 2});
m.insert({"A", 3});
m["C"];
m.emplace("B", 4);