【LeetCode-C】25-Jul

随机数

以下是C++中随机数生成的系统介绍，涵盖传统方法、现代库、分布类型及实践建议：

🔧 传统方法：`rand()`与`srand()`

基本原理

rand()

生成

到

RAND_MAX

（通常为32767）的伪随机整数。需配合

srand(seed)

设置种子，否则每次运行序列相同。

#include <cstdlib>
#include <ctime>
int main() {
    srand(time(nullptr));          // 时间作为种子
    int num = rand() % 100;        // 生成0-99的随机数[2,5](@ref)
    float frac = rand() / static_cast<float>(RAND_MAX); // [0,1)浮点数[1](@ref)
}

局限性
- 分布不均匀（模运算导致低位重复）7
- 随机性质量低，周期短，不适合加密或高精度模拟6,8。

⚙️ 现代C++11随机数库（`<random>`）

核心组件

组件类型	代表类/引擎	特点
随机数引擎	`std::mt19937` (梅森旋转)	高质量、长周期(2^19937-1)，适合多数场景1,8
	`std::minstd_rand` (线性同余)	速度快，但周期较短
随机数分布器	`uniform_int_distribution`	均匀整数分布
	`normal_distribution`	正态分布
种子源	`std::random_device`	基于硬件的真随机数（可能回退为伪随机）3,9

代码示例

#include <random>
#include <iostream>
int main() {
    std::random_device rd;  // 硬件种子源
    std::mt19937 gen(rd()); // 初始化梅森引擎
    std::uniform_int_distribution<> dis(10, 20); // [10,20]整数
    std::normal_distribution<> norm(0.0, 1.0);   // 均值0, 标准差1

    std::cout << dis(gen) << "\n";  // 输出均匀分布随机数
    std::cout << norm(gen) << "\n"; // 输出正态分布随机数[3,8](@ref)
}

📊 常用随机数分布类型

分布类型	类名	应用场景	示例代码
均匀分布（整数）	`std::uniform_int_distribution`	抽奖、游戏事件	`dis(gen)` 生成区间内等概率整数7,9
均匀分布（浮点）	`std::uniform_real_distribution`	模拟连续现象（如物理运动）	`dis(1.0, 2.0)` 生成(1.0, 2.0)浮点数3
正态分布	`std::normal_distribution`	统计学、自然现象模拟（身高、误差）	`norm(gen)` 生成高斯分布随机数2,8
伯努利分布	`std::bernoulli_distribution`	二值事件（如抛硬币）	`dis(gen)` 返回true的概率为0.63

⚠️ 关键实践建议

种子管理
- 避免固定种子（如 srand(0)），优先用 std::random_device 或 time(nullptr)6,9。
- 多次生成时重用引擎对象，而非重复创建（避免性能开销）8。
性能优化
- 轻量场景可用 std::minstd_rand；高要求场景用 std::mt199373,6。
- 分布对象构造成本低，可重复使用。
常见陷阱
- 传统 rand() % N 在 N 非 RAND_MAX+1 因子时分布不均7。
- 浮点数范围错误：rand() / RAND_MAX 结果为整数除法，需显式转浮点1。

🎯 应用场景

游戏开发：敌人行为、道具掉落（均匀分布）8
科学模拟：蒙特卡洛方法（正态分布）6
密码学：密钥生成（需结合 std::random_device）8
数据增强：机器学习数据集扩充（随机扰动）8

💎 总结

基础需求：用 rand() + srand(time(nullptr)) 快速实现。
高质量需求：必选 <random> 库，组合引擎（如 mt19937）与分布器（如 uniform_int_distribution）。
特殊分布：直接使用正态、伯努利等高级分布器简化代码3,8。

完整代码示例及进阶技巧可参考：C++随机数生成技术详解 6；现代C++随机数应用 8。

万能头

在C++中，万能头文件特指 <bits/stdc++.h>，它是一个非标准但广泛用于竞赛编程的头文件，通过预处理器一次性包含几乎所有C++标准库头文件。以下是其核心要点：

🔍 万能头文件是什么？

定义：<bits/stdc++.h> 是GCC编译器特有的头文件，内部聚合了C++标准库的绝大多数头文件（如<iostream>、<vector>、<algorithm>等）1,4。
目的：简化代码编写，避免手动包含多个头文件，尤其适用于算法竞赛和快速原型开发1,2。

⚖️ 优缺点分析

✅ 优点

高效便捷
- 一行代码替代数十行头文件包含，提升编码效率2,8。
- 竞赛中避免因漏写头文件导致编译失败1,10。
覆盖全面 支持STL容器、字符串处理、数学计算、输入输出等常用功能，涵盖C++11/14/17特性4,7。

❌ 缺点

编译性能下降
- 包含大量未使用的头文件，显著增加编译时间（大型项目编译时间可能增长300%+）1。
- 示例：1万行代码的编译时间从8.5秒增至21.4秒1。
可移植性差
- 仅支持GCC和Clang（需GNU C++库），MSVC等编译器不支持1,4。
- 跨平台项目可能因头文件缺失编译失败。
命名污染 与using namespace std;结合易引发命名冲突（如自定义类list与std::list混淆）1,8。
学习障碍 初学者过度依赖会忽略各头文件的具体作用，影响对C++标准库的理解2,8。

🌐 编译器支持情况

编译器	支持情况	版本要求
GCC	✅ 完全支持	4.8+
Clang	⚠️ 需GNU C++库	3.4+
MSVC	❌ 不支持	-
1,4

🛠️ 适用场景 vs 规避场景

场景类型	建议	示例
编程竞赛	✅ 推荐	Codeforces、ACM-ICPC
教学演示/快速验证	✅ 推荐	课堂示例、算法原型
大型工程项目	❌ 避免	Chromium、LLVM等生产代码1
跨平台开发	❌ 避免	Windows/Linux混合编译
严格编译时效要求	❌ 避免	CI/CD流水线
1,8

🔧 替代方案

手动包含常用头文件 精选高频头文件组合，如：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

1,9

自定义聚合头文件 创建my_std.hpp，按需包含项目所需头文件：
```
#pragma once
#include <vector>
#include <map>
#include <algorithm>
```
1,3

条件编译兼容 跨平台时区分编译器：

#if defined(__GNUC__) && !defined(__clang__)
    #include <bits/stdc++.h>
#else
    #include <iostream>
    // 手动补充其他头文件
#endif

C++20模块（未来趋势） 使用标准库模块替代头文件：
```
import std.core;  // 提案中，尚未完全实现
```
1

💎 实践建议

竞赛场景：直接使用#include <bits/stdc++.h> + using namespace std;，专注解题效率2,10。
学习阶段：手动包含头文件，深入理解各库的归属（如<vector>定义容器、<cmath>提供数学函数）8,9。
工程项目：用预编译头（PCH） 技术优化编译速度，而非万能头1。

📌 总结

<bits/stdc++.h>是C++竞赛编程的“利器”，但需警惕其编译开销和可移植性缺陷。理解头文件的作用机制比盲目依赖万能头更重要——正如Bjarne Stroustrup所言：“用抽象管理复杂性，而非消除对复杂性的认知。”1 合理选择工具，方能平衡效率与工程严谨性。

快排

快速排序中的左右指针法和快慢指针法是两种不同的分区（Partition）策略，它们在实现逻辑、指针移动方式和适用场景上存在显著差异。以下从核心原理、实现步骤、效率和应用场景四个维度进行对比分析：

🔍 核心原理与指针定义

左右指针法（对撞指针）
- 原理：基于双向遍历，通过左右指针从数组两端向中间逼近，交换不符合分区规则的元素5,7。
- 指针角色：
  - left：从左侧向右扫描，寻找大于基准值的元素。
  - right：从右侧向左扫描，寻找小于基准值的元素6,7。
- 终止条件：left >= right（指针相遇或错开）3,7。
快慢指针法（前后指针）
- 原理：基于同向遍历，慢指针维护分区边界，快指针扫描并交换小于基准值的元素3,9。
- 指针角色：
  - slow：标记下一个小于基准值的位置，初始为起始位置。
  - fast：遍历整个数组，发现小于基准值的元素时与slow交换并右移slow9。
- 终止条件：fast遍历完数组，最后将基准值与slow位置交换9。

⚙️ 分区过程与代码实现

左右指针法步骤

选择基准值（如arr[left]）。
right左移直至找到小于基准值的元素；left右移直至找到大于基准值的元素。
交换arr[left]和arr[right]，重复直至left >= right。
交换基准值与arr[right]，完成分区6,7。 代码片段：

while (left < right) {
    while (left < right && arr[right] >= key) right--;
    while (left < right && arr[left] <= key) left++;
    swap(arr[left], arr[right]);  // 交换不满足条件的元素
}
swap(arr[begin], arr[right]);    // 基准值归位

快慢指针法步骤

选择基准值（如arr[0]），slow指向起始位置。
```
fast
```
从
```
slow+1
```
开始遍历：
- 若arr[fast] < key，则slow++并交换arr[slow]与arr[fast]。
遍历结束后，交换arr[0]与arr[slow]，分区完成9。 代码片段：

slow = begin
for fast in range(begin+1, end+1):
    if arr[fast] < key:
        slow += 1
        swap(arr[slow], arr[fast])
swap(arr[begin], arr[slow])  // 基准值归位

⏱️ 效率与稳定性对比

维度	左右指针法	快慢指针法
时间复杂度	平均 O(n log n)，最坏 O(n²)（有序数组）8	同左，但交换次数更少9
交换次数	较多（需多次左右交换）7	较少（仅与慢指针交换）9
稳定性	不稳定（交换可能打乱相等元素顺序）7	不稳定（同左）9
边界处理	需注意指针移动顺序（如先右后左）6	逻辑简单，不易越界9

🎯 适用场景与选择建议

左右指针法适用场景：
- 需显式处理元素交换的优化场景（如三数取中优化）6,7。
- 对代码可读性要求较高的教学场景（逻辑直观）7。
快慢指针法适用场景：
- 追求代码简洁性（如算法竞赛或面试手写）9。
- 数据量中等且需减少交换次数的场景3,9。

💡 实践建议：若需避免最坏时间复杂度（如有序数组），两者均需结合随机化基准值或三数取中法6,8。

💎 总结

左右指针法通过双向逼近实现分区，逻辑清晰但交换频繁；快慢指针法通过同向扫描减少交换，代码更简洁但分区逻辑略抽象。两者核心目标均为将数组划分为基准值两侧的子序列，实际选择需结合具体需求：

教学/显式交换优化 → 左右指针法6,7
代码简洁/减少交换 → 快慢指针法3,9

两种方法均可通过基准值优化（如随机选择）提升性能，避免退化至 O(n²) 的最坏情况8。

三路快排

三路快速排序（3-Way QuickSort）是传统快速排序的优化版本，通过将数组划分为小于基准值、等于基准值和大于基准值三个区域，显著提升对含大量重复元素数组的排序效率。以下从核心原理、实现步骤、性能分析到应用场景进行全面解析：

🔍 算法思想与核心优势

三路划分原理

分区目标：将数组分为三部分：
- 小于区（< pivot）：位于左侧。
- 等于区（= pivot）：位于中部，无需再排序。
- 大于区（> pivot）：位于右侧1,3,7。
核心改进：传统快排将重复元素分散到左右子数组，导致递归深度增加；三路快排将重复元素集中到等于区，避免冗余操作3,9。

核心优势

高效处理重复元素：当重复元素占比高时，时间复杂度从传统快排的 O(n²) 优化至 O(n)3,8。
减少递归深度：等于区不参与递归，子问题规模更均衡7,9。

⚙️ 分区过程与指针操作

指针定义

lt（Less Than）：指向小于区的右边界（初始为low）。
gt（Greater Than）：指向大于区的左边界（初始为high）。
current：遍历指针（初始为low+1）3,6,7。

分区步骤

遍历规则（
```
current ≤ gt
```
时循环）：
1. arr[current] < pivot：交换arr[current]与arr[lt]，lt++，current++。
2. arr[current] > pivot：交换arr[current]与arr[gt]，gt--（current不动，需检查新元素）。
3. arr[current] == pivot：current++3,7。
终止条件：
```
current > gt
```
，此时数组划分为：
- [low, lt-1]：小于基准值。
- [lt, gt]：等于基准值。
- [gt+1, high]：大于基准值6,7。

递归排序

仅对小于区和大于区递归排序，等于区已就位4,9。

# 伪代码示例
def three_way_quicksort(arr, low, high):
    if low >= high: return
    lt, gt = partition(arr, low, high)  # 分区操作
    three_way_quicksort(arr, low, lt-1)  # 排序小于区
    three_way_quicksort(arr, gt+1, high) # 排序大于区

⏱️ 时间复杂度与空间复杂度

场景	时间复杂度	解释
最佳/平均	O(n log n)	数据随机分布时，递归树平衡4,8。
最坏	O(n²)	基准值始终为极值（可通过优化避免）4。
大量重复元素	O(n)	等于区快速收敛，子问题规模指数级减少3,8。
空间复杂度	O(log n)	递归栈深度，与传统快排相同4,7。

💡 关键点：通过随机化基准值或三数取中法（选左、中、右三元素的中位数）可避免最坏情况6,8。

🚀 性能优化技巧

小数组优化 当子数组长度 < 15 时，改用插入排序（插入排序在小规模数据中更高效）9。
避免重复递归等于区 等于区元素已有序，跳过递归减少函数调用开销7。
随机化基准值 交换arr[low]与随机位置的元素，降低最坏情况概率6,9。

🆚 与传统快排的对比

维度	传统快排	三路快排
分区方式	二路（< pivot 和 ≥ pivot）	三路（<、=、> pivot）
重复元素处理	重复元素分散递归，效率退化至 O(n²)	重复元素集中处理，效率保持 O(n)
适用场景	重复元素较少	大量重复元素（如日志数据、用户行为数据）3,9
代码复杂度	简单（双指针）	略复杂（三指针+交换逻辑）7

💻 代码实现（C++示例）

#include <iostream>
#include <vector>
using namespace std;
void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}
void threeWayQuickSort(vector<int>& arr, int low, int high) {
    if (low >= high) return;
    // 三数取中优化基准值选择
    int mid = low + (high - low) / 2;
    if (arr[mid] < arr[low]) swap(arr[low], arr[mid]);
    if (arr[high] < arr[low]) swap(arr[low], arr[high]);
    if (arr[mid] < arr[high]) swap(arr[mid], arr[high]);
    int pivot = arr[low];
    int lt = low, gt = high, current = low + 1;
    while (current <= gt) {
        if (arr[current] < pivot) {
            swap(arr[current], arr[lt]);
            lt++, current++;
        } else if (arr[current] > pivot) {
            swap(arr[current], arr[gt]);
            gt--;
        } else {
            current++;
        }
    }
    threeWayQuickSort(arr, low, lt - 1);
    threeWayQuickSort(arr, gt + 1, high);
}

🎯 适用场景

高重复数据集：如用户行为日志、传感器数据、词频统计等3,9。
稳定性要求低：快排本身不稳定，但三路快排通过减少交换次数提升效率。
大规模数据排序：工业级排序库（如Java的Arrays.sort()）在检测到重复元素时自动切换三路快排3。

💎 总结

三路快速排序通过三指针分区策略，将重复元素收敛至中间区域，彻底解决传统快排面对重复数据时的性能瓶颈。其核心优势在于：

时间复杂度优化：大量重复元素时从 O(n²) → O(n)3,8。
工程实用性强：结合随机化基准值和小数组优化，适合处理真实世界的高重复数据集7,9。

正如算法大师Robert Sedgewick所言：“三路划分是快速排序在处理重复键时的救星。” 掌握此算法，方能在数据洪流中游刃有余。

单调栈

单调栈（Monotonic Stack）是一种特殊的栈数据结构，其核心特性是栈内元素始终保持单调递增或单调递减的顺序。它通过动态维护元素的单调性，高效解决序列中“下一个更大/更小元素”、“区间最值”等经典问题，时间复杂度为均摊 O(n)。以下是其核心内容详解：

⚙️ 定义与基本特性

单调递增栈
- 栈内元素从栈底到栈顶严格递增（栈顶最小）。
- 适用场景：寻找元素右侧第一个更小值、计算柱状图最大矩形1,3,7。
单调递减栈
- 栈内元素从栈底到栈顶严格递减（栈顶最大）。
- 适用场景：寻找元素右侧第一个更大值、接雨水问题1,4,6。

与普通栈的区别：

普通栈仅支持后进先出（LIFO），无顺序约束。
单调栈在入栈时需弹出破坏单调性的元素，确保栈内有序1,7。

🔍 核心原理与操作机制

维护单调性的流程（以单调递减栈为例）

遍历序列：依次处理每个元素。
比较与弹出：若当前元素 > 栈顶元素，则弹出栈顶（此时当前元素为栈顶的“下一个更大元素”）。
入栈：当前元素入栈，保持栈的单调递减性1,3,6。

操作模板（Java）：

// 单调递减栈模板（寻找下一个更大元素）
Deque<Integer> stack = new ArrayDeque<>();
for (int i = 0; i < nums.length; i++) {
    while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
        int idx = stack.pop();  // 弹出栈顶，记录结果：nums[i] 是 nums[idx] 的下一个更大元素
        res[idx] = nums[i]; 
    }
    stack.push(i);  // 当前索引入栈
}

时间复杂度分析：每个元素最多入栈、出栈各一次，整体 O(n)1,3,7。

📊 典型应用场景与问题解析

下一个更大元素（NGE）

问题：对数组每个元素，找到右侧第一个比它大的数。
解法：单调递减栈 + 从左向右遍历。
- 示例：[3,1,4,5,2] → NGE: [4,4,5,-1,-1]1,6,7。

接雨水问题

问题：计算柱状图中凹槽能容纳的雨水量。
解法：单调递减栈维护左边界，计算凹槽宽度和高度。
- 关键公式：水量 = (min(左边界高度, 当前高度) - 凹槽底高度) × 宽度1,4。

柱状图最大矩形面积

问题：求直方图中面积最大的矩形。
解法：单调递增栈 + 首尾补0处理边界。
- 弹出元素时计算：面积 = 高度 × (右边界 - 左边界 - 1)1,3,4。

每日温度问题

问题：对于每天温度，求需等待几天才有更高温度。
解法：单调递减栈，记录下标差（i - 栈顶索引）4,6。

⚠️ 实现模板与技巧

通用解题步骤：

确定单调性方向：
- 找更大元素 → 单调递减栈；找更小元素 → 单调递增栈1,4。
存储索引而非值：便于计算距离（如矩形宽度、天数差）3,7。
处理边界：
- 数组首尾添加虚拟元素（如高度0），避免空栈判断1,3。

常见错误：

忽略重复元素：若值可重复，需在比较条件中处理等号（如 >= 或 <=）4。
混淆值与索引：比较时需用 nums[stack.peek()] 而非 stack.peek()3,7。

🚀 进阶应用与优化

双向单调栈
- 同时计算左右边界（如接雨水问题）：
  - 左栈记录左侧最大值，右栈记录右侧最大值，取较小值计算水量1,4。
- 优势：逻辑更清晰，避免嵌套循环。
与动态规划结合
- 优化股票跨度问题：单调栈维护价格递减序列，快速定位前一个更高价日1,5。
循环数组处理
- 扩展数组为 2n 长度，用 i % n 模拟环形遍历4,6。

💎 总结与学习建议

单调栈的核心价值在于将序关系的嵌套查询优化至线性时间，适用于序列中“局部序关系决定全局解”的问题。关键要点总结如下表：

特性	应用场景	时间复杂度
单调递增栈	右侧首个更小元素、柱状图最大矩形	O(n)
单调递减栈	右侧首个更大元素、接雨水问题	O(n)

学习建议：

从模板入手：掌握基础模板后，通过经典问题（如LeetCode 739、84、42）练习变形3,6,7。
可视化调试：手动画出栈状态变化，理解元素入栈/出栈的逻辑3,7。
扩展练习：尝试环形数组（503）、双向单调栈（42）等变体4,6。

单调栈的威力在于其 “空间换序” 的本质——通过缓存未处理的元素，并利用单调性快速定位边界，将暴力 O(n²) 优化至 O(n)。掌握其核心思想，可高效解决一系列经典算法难题1,7。

单调队列

单调队列（Monotonic Queue）是一种基于双端队列（Deque）实现的数据结构，其核心特性是队列内元素始终保持单调递增或单调递减的顺序。它通过动态维护数据的单调性，高效解决滑动窗口极值、动态规划优化等问题，将时间复杂度从暴力解的 O(n²) 降低至 O(n)。以下是其核心内容详解：

⚙️ 定义与核心特性

基本定义：
- 单调递增队列：队头到队尾元素递增，队头为最小值（例如 [1,3,5]）1,6。
- 单调递减队列：队头到队尾元素递减，队头为最大值（例如 [9,6,2]）6,9。
与普通队列的区别：
- 普通队列仅支持 FIFO（先进先出），无顺序约束。
- 单调队列在入队时需动态剔除破坏单调性的元素，并支持双端操作（队头出队、队尾入队）3,8。

🔍 工作原理与操作流程

入队操作（维护单调性）

单调递减队列：新元素入队时，从队尾向前移除所有小于当前值的元素，再插入新元素。示例：队列 [8,5,3] 插入 6 → 移除 5,3 → 新队列 [8,6]3,6。
单调递增队列：移除所有大于当前值的元素后再插入9。

出队操作（维护窗口范围）

当队头元素超出滑动窗口范围（如索引差 ≥ 窗口大小 k），将其从队头移除7,9。

查询操作（获取极值）

队头元素即为当前窗口的最大值（递减队列）或最小值（递增队列），时间复杂度 O(1)1,6。

操作流程示例（滑动窗口最大值）

步骤	操作	队列状态（递减）	当前窗口最大值
插入 `1`	`push(1)`	`[1]`	-
插入 `3`	移除 `1`，`push(3)`	`[3]`	-
插入 `-1`	`push(-1)`	`[3,-1]`	`3`（窗口完整）
插入 `-3`	`push(-3)`	`[3,-1,-3]`	`3`
插入 `5`	移除 `-1,-3`，`push(5)`	`[5]`	`5`

📊 典型应用场景

滑动窗口极值问题

问题：给定数组和窗口大小 k，求每个窗口的最大值/最小值。
解法：单调递减队列维护最大值，单调递增队列维护最小值。示例：nums=[1,3,-1,-3,5], k=3 → 最大值输出 [3,3,5]5,9。

动态规划优化

适用方程：f[x] = max/min{g(k)} + w[x]（b[x] ≤ k < x 且 b[x] 单调不减）。
优化思路：单调队列维护 g(k) 的候选集，避免重复计算区间极值1,7。

经典问题扩展

广告牌最大矩形：通过单调队列（或单调栈）计算每个建筑左右边界，求最大矩形面积（例题见1,2）。
接雨水问题：结合单调递减队列动态计算凹槽水量6。
最长递增子数组：单调递增队列维护连续递增序列6。

⚖️ 实现模板与复杂度

Java 实现（单调递减队列）

import java.util.Deque;
import java.util.LinkedList;
class MonotonicQueue {
    private Deque<Integer> deque = new LinkedList<>();
    public void push(int value) {
        while (!deque.isEmpty() && deque.getLast() < value) {
            deque.removeLast();  // 移除队尾小于当前值的元素
        }
        deque.addLast(value);
    }
    public void pop(int value) {
        if (!deque.isEmpty() && deque.getFirst() == value) {
            deque.removeFirst();  // 移除过期队头元素
        }
    }
    public int max() {
        return deque.getFirst();  // 返回当前最大值
    }
}

C++ 实现（滑动窗口最大值）

vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    deque<int> dq;
    vector<int> res;
    for (int i = 0; i < nums.size(); i++) {
        while (!dq.empty() && nums[i] >= nums[dq.back()]) 
            dq.pop_back();  // 维护递减性
        dq.push_back(i);
        if (dq.front() <= i - k) 
            dq.pop_front();  // 移除越界队头
        if (i >= k - 1) 
            res.push_back(nums[dq.front()]);  // 记录窗口最大值
    }
    return res;
}

时间复杂度与空间复杂度

操作	时间复杂度	空间复杂度
插入/删除	均摊 O(1)	O(k)
查询极值	O(1)	-
整体遍历	O(n)	-

⚠️ 常见错误与技巧

索引 vs. 值：
- 队列存储索引而非值，便于判断元素是否在窗口内3,9。
重复元素处理：
- 比较时需包含等号（如 >= 或 <=），避免遗漏同值元素7。
边界处理：
- 虚拟首尾元素（如补 0）可简化代码，避免空队列判断1,7。

💎 总结与学习建议

单调队列的核心价值在于通过 “空间换序” 动态维护候选极值序列，将嵌套查询优化至线性时间。其应用场景可总结如下：

问题类型	适用队列类型	经典例题
滑动窗口最大值	单调递减队列	LeetCode 239
动态规划区间极值优化	单调递增/递减	广告牌问题（POJ 2823）
连续子数组极值	单调队列 + 前缀和	“切蛋糕”问题

学习建议：

从模板入手：掌握基础模板后，通过 LeetCode 239 和 LeetCode 84 练习变形。
可视化调试：手动画出入队/出队过程（如 Visualgo 动画演示）。
进阶扩展：学习单调队列在环形数组（LeetCode 503）和斜率优化 DP 中的应用1,7。

单调队列的威力在于其 “以序换效” 的本质——通过缓存可能成为未来极值的候选元素，并利用单调性快速剔除无效数据，将暴力 O(n²) 优化至 O(n)。掌握其核心思想，可高效解决一系列经典算法难题。

__builtin_popcount

__builtin_popcount 是 GCC 和 Clang 编译器提供的内置函数，用于高效计算无符号整数二进制表示中 1 的个数（Population Count）。以下从核心原理、使用场景、性能优化到替代方案进行全面解析：

🔍 核心原理与函数定义

函数原型

int __builtin_popcount(unsigned int x); // 32位整数
int __builtin_popcountll(unsigned long long x); // 64位整数

参数：无符号整数（unsigned int 或 unsigned long long）。
返回值：二进制中 1 的个数2,5。

底层实现机制

硬件加速：若 CPU 支持 POPCNT 指令（x86 架构从 SSE4.2 引入），编译器直接生成该指令，单条指令完成位计数，时间复杂度 O(1)1,3。
软件回退：若无 POPCNT 支持，编译器自动切换为高效位操作算法：
- 二分法：分治合并相邻位的 1 的数量，时间复杂度 O(log₂ n)。
```
u = (u & 0x55555555) + ((u >> 1) & 0x55555555); // 每2位分组统计
u = (u & 0x33333333) + ((u >> 2) & 0x33333333); // 每4位合并
u = (u & 0x0F0F0F0F) + ((u >> 4) & 0x0F0F0F0F); // 每8位合并
// ... 最终合并为32位结果
```
- 查表法：预计算 8 位整数的 1 的数量表（256 元素），分段查表求和4,7。

⚡ 性能优势与对比

实现方法	时间复杂度	适用场景	性能对比（相对时间）
`__builtin_popcount`（硬件）	O(1)	支持 POPCNT 指令的 CPU	1x（基准）
二分法	O(log₂ n)	通用算法	3~5x 慢
Brian Kernighan 算法	O(k)	`1` 的位数极少时（k 为实际位数）	10x 慢
逐位循环	O(n)	简单实现	20x 慢 4,7

✅ 实测案例：对 1 亿次 __builtin_popcount 调用耗时约 21ms，而手动循环实现需 500ms+1。

🛠️ 使用场景与示例

位图操作与组合枚举

子集筛选：在状态压缩算法中，快速过滤满足位数要求的组合。

for (int mask = 0; mask < (1 << n); mask++) {
    if (__builtin_popcount(mask) == k) { // 筛选含 k 个元素的子集
        // 处理逻辑
    }
}

数学与算法优化

判断 2 的幂：(x & (x-1)) == 0 且 __builtin_popcount(x) == 1。
汉明距离：计算两数异或后的 1 的个数。

实际应用案例

路径规划：在网格问题中用二进制表示移动路径

int path = 0b1100101; // 路径编码
int down_steps = __builtin_popcount(path); // 统计向下次数

⚠️ 局限性与注意事项

可移植性问题：
- 仅 GCC/Clang 支持，MSVC 不可用（需改用 std::popcount 或手动实现）5,6。
- 硬件依赖：老旧 CPU 无 POPCNT 指令时性能下降。
类型匹配：
- 32 位用 __builtin_popcount，64 位用 __builtin_popcountll。
- 禁止传入负数（需先转为无符号类型）6。
工程权衡：
- 高性能场景：优先依赖硬件指令（需检测 CPU 支持性）。
- 跨平台场景：使用 C++20 标准库 std::popcount（<bit> 头文件）6。

🔄 替代方案（C++20 前）

方法	代码示例	适用场景
Brian Kernighan	`while (n) { n &= n-1; count++; }`	`1` 的位数较少时
查表法	预计算 `table[256]`，分段求和7	频繁调用且内存允许
二分法	分治合并（见上文）	无硬件加速且需稳定性能

💎 总结

核心价值：__builtin_popcount 以近硬件极限的速度解决位计数问题，是算法竞赛和位操作密集型应用的利器⚡。
工程建议：
- GCC/Clang 环境：直接使用，搭配 -mpopcnt 编译选项确保硬件加速1,3。
- 生产代码：C++20+ 项目优先用 std::popcount；旧项目可封装适配层，自动切换内置函数与手动实现6。
- 可移植性：通过 __has_builtin(__builtin_popcount) 检测编译器支持性5。

正如 Linux 内核开发者所言：“位操作是系统编程的基石，而 popcnt 是其中最高效的原子工具之一。” 掌握其原理与应用，可显著提升底层性能优化能力。

__lg

__lg 是 GCC 和 Clang 编译器提供的内置函数（非标准 C++ 函数），用于高效计算无符号整数的二进制表示中最高有效位（MSB）的位置（从 0 开始计数）。以下是其核心原理、使用场景、实现方式及注意事项的详细解析：

🔍 核心功能与数学原理

功能定义
- 输入一个无符号整数 x（x > 0），返回其二进制形式中最高位 1 的位置索引（索引从 0 开始）。
- 数学等价
  ：
```
\text{\_\_lg}(x) = \lfloor \log_2(x) \rfloor
```
  - 例如：
    - __lg(8) = 3（8 的二进制为 1000，最高位在第 4 位，索引为 3）1,2。
    - __lg(5) = 2（5 的二进制为 101，最高位在第 3 位，索引为 2）1。
输入要求
- 必须为无符号整数类型（如 unsigned int、uint64_t）。
- 禁止输入 x = 0：此时行为未定义（可能导致程序崩溃或错误结果）1,2。

⚙️ 底层实现机制

__lg 的底层通过编译器优化实现高效计算，通常有两种方式：

硬件指令加速：
- 若 CPU 支持 CLZ（Count Leading Zeros）指令（如 x86 的 BSR 指令），编译器直接生成该指令： \text{\_\_lg}(x) = 31 - \text{\_\_builtin\_clz}(x) \quad \text{(32 位整数)} 时间复杂度为 O(1)1。

软件算法回退：

若无硬件支持，编译器使用二分法或查表法计算：

u = x;
u |= u >> 1;  // 将最高位1扩散至低位
u |= u >> 2;
u |= u >> 4;
u |= u >> 8;
u |= u >> 16;
return count_ones(u) - 1;  // 统计1的个数并减1

时间复杂度为

O(log n)

。

⚡ 性能对比

方法	时间复杂度	适用场景	性能（相对时间）
`__lg`（硬件支持）	O(1)	支持 `CLZ` 指令的 CPU	1x（基准）
`std::bit_width(x)-1`	O(log n)	C++20 标准库	1.5~2x 慢
手动位操作	O(log n)	无编译器扩展支持	3~5x 慢
`std::log2(x)`	O(1)	需浮点数结果（非整数索引）	10x 慢（含浮点转换）

💡 实测案例：对 1 亿次 __lg 调用，硬件加速仅需 15ms，而手动位操作需 50ms+1。

🛠️ 应用场景

算法优化
- 二分查找：快速计算中间点索引 mid = (left + right) >> 1 的等效对数形式1。
- 线段树/区间树
  ：确定区间长度对应的层级：
```
int tree_height = __lg(interval_length) + 1;  // 计算树高
```

位运算与状态压缩

枚举子集时筛选固定位数状态：

for (int mask = 0; mask < (1 << n); mask++) {
    if (__builtin_popcount(mask) == k) {  // 结合 __builtin_popcount
        // 处理含 k 个元素的子集
    }
}

数学计算替代
- 避免浮点运算开销，用整数指令替代

     log2(x)

 ：

 ```
 int bits_required = __lg(n) + 1;  // 计算表示 n 所需的最小比特数
 ```

⚠️ 注意事项与替代方案

可移植性问题
- 仅 GCC/Clang 支持：MSVC 需改用 std::bit_width(x) - 1（C++20）或手动实现1,2。
- 老旧 CPU 性能下降：无 CLZ 指令时退化为软件算法。
输入合法性检查
- 必须确保

     x > 0

 ：

 ```
 if (x == 0) return -1;  // 显式处理 x=0
 else return __lg(x);
 ```

替代方案实现

场景	推荐方案	示例代码
C++20 标准	`#include <bit>` `std::bit_width(x)-1`	`int pos = std::bit_width(8)-1; // 3`
通用算法	二分法 + 位操作	见上文软件算法实现
浮点数兼容	`std::log2(x)` + 取整	`int pos = static_cast<int>(std::log2(x));`

💎 总结

核心价值：__lg 以近硬件极限的速度计算最高有效位位置，是算法竞赛和位操作密集型系统的利器⚡。
工程建议
：
- GCC/Clang 环境：直接使用，搭配 -O2 编译选项确保优化。
- 生产代码：C++20+ 项目优先用 std::bit_width；旧项目封装适配层。
- 安全边界：强制检查 x>0，避免未定义行为。

正如 Linux 内核开发者所言：“最高位索引是位操作的基石，而 __lg 是其最高效的实现。” 掌握其原理，可显著提升底层性能优化能力。

using

在 C++ 中，using 和 typedef 均用于定义类型别名，但二者在语法、功能和使用场景上存在显著差异。以下是结合 C++11 及后续标准的详细对比分析：

⚙️ 核心功能与语法对比

基本类型别名

typedef（传统方式） 语法为 typedef 原类型新类型名，适用于简单类型：
```
typedef int Integer;       // 定义 int 的别名
typedef void (*FuncPtr)(int, int);  // 函数指针别名
```
缺点：函数指针等复杂类型需将别名嵌入原类型中，可读性较差1,2。

using（C++11 引入） 语法为 using 新类型名 = 原类型，更直观：

using Integer = int;                     // 等价于 typedef int Integer
using FuncPtr = void (*)(int, int);      // 函数指针别名更清晰

优势：类似赋值语法，复杂类型声明更易读1,3,4。

🧩 核心差异：模板别名支持

`typedef` 的局限性

无法直接定义模板别名，需包裹在结构体中：

template <typename T>
struct MyVector {
    typedef std::vector<T> type;  // 嵌套定义
};
MyVector<int>::type vec;          // 使用需加 ::type

代码冗余，且需额外作用域访问1,3,5。

`using` 的模板别名

直接支持模板别名定义：

template <typename T>
using Vec = std::vector<T>;  // 直接定义别名
Vec<int> numbers;            // 直接使用

优势：

简化泛型编程，避免嵌套结构3,11；
支持复杂模板（如

  std::enable_if

）：

template <typename T>
using EnableIfInt = typename std::enable_if<std::is_integral<T>::value, T>::type;

📌 `using` 的扩展功能

using 不仅用于类型别名，还支持以下场景：

引入命名空间成员

namespace NS { void foo(); int value; }
int main() {
    using NS::foo;       // 引入 foo
    using NS::value;     // 引入 value
    foo();               // 直接调用
    return value;
}

注意：避免在头文件中使用 using namespace，防止命名污染6,8。

解决继承中的名称隐藏

派生类可通过 using 引入基类成员：

class Base {
public:
    void func(int x) {}
};
class Derived : public Base {
public:
    using Base::func;    // 引入基类 func
    void func(double y) {}  // 派生类重载
};
Derived d;
d.func(10);  // 调用 Base::func(int)，避免被隐藏[1,4](@ref)

继承构造函数（C++11）

class Base {
public:
    Base(int x) {}
};
class Derived : public Base {
public:
    using Base::Base;  // 继承基类构造函数
};
Derived d(42);        // 调用 Base(int)[4,9](@ref)

⚖️ 使用场景与推荐实践

场景	推荐方案	示例/说明
简单类型别名	`typedef` 或 `using`	无显著差异，但 `using` 语法更统一3,5。
函数指针/复杂类型	`using`	语法更清晰：`using FuncPtr = void()(int)` vs `typedef void(FuncPtr)(int)`4。
模板别名	`using`	`typedef` 无法直接支持，`using` 是唯一方案1,11。
跨平台兼容性	`typedef`	需兼容 C 或 C++98 的旧代码时使用2,9。
引入基类成员/构造函数	`using`	`typedef` 无此功能4,9。

工程实践建议：

现代 C++ 项目：优先使用 using，尤其在模板和复杂类型场景3,5。
旧代码维护：保留 typedef 以保证兼容性。
命名空间引入：局部作用域使用 using NS::member，避免全局 using namespace6,8。

💎 总结

特性	`typedef`	`using`
语法	原类型在前，别名在后	别名 = 原类型（更直观）
模板别名	❌ 不支持（需嵌套结构体）	✅ 直接支持
函数指针可读性	较差（别名嵌入原类型）	更清晰（类似赋值）
扩展功能	仅类型别名	引入命名空间成员、解决继承名称隐藏等
兼容性	✅ 兼容 C/C++98	❌ 仅 C++11 及以上

核心结论：在现代 C++ 开发中，using 凭借其语法简洁性、模板支持及扩展功能，已逐渐取代 typedef 成为类型别名的首选方案。仅在兼容旧代码或特定场景（如匿名结构体）时保留 typedef1,3,5。

局部变量

在C++中，代码块（由花括号{}界定）内部的变量定义是否会被编译器“外提”，以及定义在内部与外部的性能差异，需从作用域、存储位置和编译器优化三个角度综合分析。以下是具体结论：

🔒 变量作用域与编译器行为

(1) 作用域规则

内部定义：代码块内定义的变量（如{ int x = 10; }）具有块作用域，仅在块内可见，退出块时自动销毁。
外部定义：在代码块外部定义的变量（如函数内但在{}前）具有函数作用域，在整个函数内可见。

(2) 编译器是否“外提”？

不会自动外提作用域：编译器不会将块内变量提升到块外作用域，否则会破坏封装性并可能导致命名冲突。
可能优化存储位置：在开启优化（如
```
-O2
```
）时，编译器可能将块内变量的存储位置调整到函数栈帧的更高地址（即“外提存储地址”），但
不改变其作用域
。例如：
```
void func() {
    // 编译器可能将y的存储地址提前分配，但y的作用域仍在块内
    int x = 0;
    {
        int y = x + 1;  // y的存储可能被提前分配，但作用域不超出块
    }
}
```
这种优化避免了重复分配栈空间，但变量生命周期仍严格限定在块内。

⚡ 性能差异分析

(1) 内部定义的性能优势

栈分配效率高：块内变量在栈上分配，进出块时仅需调整栈指针（约1时钟周期），无堆内存管理的开销。
缓存友好性：局部变量更易被L1缓存命中。块内变量的集中访问可提升缓存利用率，减少缓存未命中（Cache Miss）。
减少寄存器压力：短生命周期变量可能被编译器优化到寄存器中，避免内存访问延迟。

(2) 外部定义的潜在开销

延长生命周期：外部变量在整个函数内存在，占用栈空间更久，可能导致栈帧增大，影响缓存效率。
增加寄存器竞争：长生命周期变量需长期占用寄存器或内存地址，可能限制编译器的寄存器分配优化。

(3) 性能对比场景

场景	内部定义性能	外部定义性能
变量生命周期	短（仅块内）	长（整个函数）
栈分配次数	可能多次（未优化时）	一次
缓存命中率	高（局部性强）	可能低（分散访问）
寄存器优化机会	高（短生命周期）	低（需长期占用）

✅ 关键结论：在未覆盖（无命名冲突）且开启编译器优化时，内部定义通常更优，因更符合局部性原则，利于缓存和寄存器分配。

🛠 工程实践建议

优先块内定义：
- 将变量定义在最小必要作用域内，避免污染外部命名空间，同时提升可读性和缓存性能。
- 示例：
```
// ✅ 推荐：内部定义
for (int i = 0; i < n; i++) {
    int temp = compute(i);  // 作用域限定在循环内
}
```
避免重复初始化：
- 若变量需在多个块中重复使用（如循环中的临时变量），可外提定义但
  立即初始化
  ，防止未定义行为：
```
// ✅ 外提但立即初始化
int temp;
for (int i = 0; i < n; i++) {
    temp = compute(i);  // 避免每次重新定义
}
```
警惕隐藏问题（Shadowing）：
- 内部变量若与外层同名，会隐藏外部变量。确保逻辑正确性：
```
int x = 10;
{
    int x = 20;  // 隐藏外部x，可能非预期
}
```
编译器优化指令：
- 使用-O2/-O3优化级别，允许编译器合并栈分配（如将相邻块的变量存储地址外提），减少栈指针操作次数。

💎 总结

作用域：块内变量作用域不自动外提，生命周期严格受限。
性能：块内定义通常更优（栈分配高效、缓存友好），尤其配合编译器优化时。
建议：默认在块内定义变量，仅当需跨块复用或避免重复初始化时才外提，并启用编译优化（如-O2）最大化性能。

汉字

在C++中存储汉字需理解字符编码、字符串类型和平台差异。以下是核心要点及实现方案：

⚙️ 字符编码基础

常用编码标准
- GBK/GB2312：Windows中文系统默认双字节编码（部分生僻字4字节）。
- UTF-8：变长编码（1-4字节），兼容ASCII，跨平台首选（如网页、网络传输）。
- UTF-16：定长2或4字节（代理对），Windows API内部使用（wchar_t存储）。
Unicode与编码实现
- Unicode为字符集标准，UTF-8/UTF-16是其具体编码方式。
- 汉字在Unicode中的码点范围：U+4E00至U+9FFF（基本多文种平面）。

💾 C++中的存储实现方式

使用`char`数组（多字节编码）

GBK示例

：每个汉字占2字节，英文字符1字节。

char gbk_str[] = "你好";  // 内存：D6 D0（你） + B9 FA（好）

UTF-8示例

：汉字占3字节（C++11起支持

u8

前缀）：

const char* utf8_str = u8"你好";  // 内存：E4 BD A0（你） + E5 A5 BD（好）

宽字符类型（`wchar_t`）

Windows：

wchar_t

为2字节（UTF-16），Linux为4字节（UTF-32）：

wchar_t wide_str[] = L"你好";  // Windows内存：4F60（你） + 597D（好）

现代字符串类型（C++11起）

std::u16string

**：UTF-16编码，适用于Windows：

std::u16string u16_str = u"你好";

std::u32string：UTF-32编码，平台无关但空间大。
**
```
std::string
```
（UTF-8）**：需显式指定编码，推荐跨平台使用：
```
std::string utf8_str = u8"你好";
```

🌐 平台差异与兼容性处理

Windows特有机制

API双版本：CreateFileA（ANSI/GBK） vs. CreateFileW（UTF-16）。

编码转换：用

MultiByteToWideChar

（GBK/UTF-8 → UTF-16）：

std::string utf8_str = u8"你好";
int len = MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, nullptr, 0);
std::wstring wstr(len, 0);
MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, &wstr[0], len);

控制台输出

Windows默认GBK，输出UTF-8需设置代码页：

SetConsoleOutputCP(CP_UTF8);  // 或执行命令`chcp 65001`
std::cout << u8"你好";

文件读写
- 写入UTF-8时建议加BOM（\xEF\xBB\xBF）。
- 读取时需检测编码（如BOM头），再转换到程序内部格式。

⚠️ 关键问题与最佳实践

常见陷阱
- strlen误区：统计字节数而非字符数（如UTF-8汉字算3字节）。
- 源文件编码：确保源代码文件保存为UTF-8（带BOM），编译器设置/utf-8（MSVC）或-finput-charset=UTF-8（GCC）。
推荐实践
- 跨平台：统一用UTF-8编码的std::string，避免wchar_t。
- Windows开发：优先Unicode版本API（*W后缀），内部用std::wstring。
- 复杂场景：第三方库如ICU（编码转换）、Boost.Locale（跨平台本地化）。

💎 总结

场景	推荐方案	示例/工具
跨平台文本存储/传输	UTF-8 + `std::string`	`u8"汉字"`
Windows API交互	UTF-16 + `std::wstring`	`L"汉字"` + `MultiByteToWideChar`
文件读写	显式BOM或统一编码	`fstream` + 检测BOM

关键原则：从输入到输出全程统一编码，避免混合编码导致乱码。测试时务必验证多语言环境下的行为，如中英混合字符串的截取、比较等操作。

字符串相等

在C++中判断字符串是否相等，需根据字符串类型（std::string或C风格字符串）和具体场景选择合适的方法。以下是详细总结及最佳实践：

🔍 `std::string`字符串的比较

`==`运算符（最常用）

直接比较两个std::string对象的内容是否完全相同：

#include <string>
#include <iostream>
int main() {
    std::string s1 = "Hello";
    std::string s2 = "Hello";
    if (s1 == s2) {  // 返回true
        std::cout << "字符串相等" << std::endl;
    }
}

注意：

区分大小写（如"hello" != "Hello"）。
空格和长度敏感（如"Hello" != "Hello "）。

`compare()`函数

提供更详细的比较结果（相等返回0，否则返回非零值）：

if (s1.compare(s2) == 0) {  // 等价于 s1 == s2
    std::cout << "字符串相等" << std::endl;
}

适用场景：

需判断字典序关系（如排序）时，返回值可区分大小（<0表示s1 < s2，>0表示s1 > s2）。

⚠️ C风格字符串（字符数组）的比较

C风格字符串需使用**strcmp()函数**，不可用==（否则比较的是地址而非内容）：

#include <cstring>
#include <iostream>
int main() {
    const char* str1 = "Hello";
    const char* str2 = "Hello";
    if (strcmp(str1, str2) == 0) {  // 返回0表示相等
        std::cout << "字符串相等" << std::endl;
    }
}

注意：

需包含头文件<cstring>。
同样区分大小写和空格。

🛠 特殊场景的字符串比较

忽略大小写比较

需先统一转换为小写/大写：

#include <algorithm>
#include <cctype>
bool caseInsensitiveCompare(const std::string& a, const std::string& b) {
    std::string a_lower = a;
    std::string b_lower = b;
    std::transform(a_lower.begin(), a_lower.end(), a_lower.begin(), ::tolower);
    std::transform(b_lower.begin(), b_lower.end(), b_lower.begin(), ::tolower);
    return a_lower == b_lower;
}

应用场景：用户名验证、模糊匹配等。

部分字符串比较

使用substr()或迭代器比较子串：

// 比较前n个字符
if (str1.substr(0, n) == str2.substr(0, n)) { /* 相等 */ }
// 或使用迭代器
bool partialEqual = std::equal(str1.begin(), str1.begin() + n, str2.begin());

忽略空格的比较

遍历时跳过空格字符：

bool ignoreSpaceCompare(const std::string& a, const std::string& b) {
    size_t i = 0, j = 0;
    while (i < a.size() && j < b.size()) {
        if (a[i] == ' ') { i++; continue; }
        if (b[j] == ' ') { j++; continue; }
        if (a[i] != b[j]) return false;
        i++; j++;
    }
    // 处理剩余字符
    while (i < a.size() && a[i] == ' ') i++;
    while (j < b.size() && b[j] == ' ') j++;
    return (i == a.size() && j == b.size());
}

应用场景：文本处理（如NOI题目中的字符串判等）。

⚡ 性能优化与常见陷阱

性能优化

避免拷贝：使用const std::string&传递参数，减少临时对象。

快速失败

：先比较长度，长度不等直接返回

false

，避免逐字符比较：

bool efficientCompare(const std::string& a, const std::string& b) {
    if (a.size() != b.size()) return false;
    return a == b;  // 或 a.compare(b) == 0
}

常见陷阱

==

误用于C风格字符串**：

const char* s1 = "Hello";
const char* s2 = "Hello";
if (s1 == s2)  // 比较地址而非内容！可能返回true（编译器优化），但不可靠

未处理编码差异：多字节字符（如中文）需确保字符串编码一致（如UTF-8）。
生命周期问题：c_str()返回的指针在std::string修改后失效。

💎 总结：不同场景下的推荐方法

场景	推荐方法	示例
`std::string`内容比较	`==` 运算符	`if (str1 == str2)`
需获取字典序关系	`compare()`	`if (str1.compare(str2) == 0)`
C风格字符串比较	`strcmp()`	`if (strcmp(cstr1, cstr2) == 0)`
忽略大小写比较	转换为小写后使用`==`	见第三节示例
高性能场景（长字符串）	先比较长度，再比较内容	见第四节优化代码

最佳实践：

优先使用std::string而非C风格字符串，避免指针陷阱。
明确比较需求（是否大小写敏感、是否忽略空格），选择对应策略。
对性能敏感的场景（如大文本处理），采用长度预判和引用传参优化。

字符串比较

在 C++ 中，字符串比较遵循**字典序（Lexicographical Order）**规则，具体实现方式因字符串类型（C 风格字符串或 std::string）而异。以下是核心规则和实现方法的详细说明：

🧠 基本比较规则

逐字符比较 从左向右依次比较每个字符的编码值（如 ASCII 或 Unicode）：
- 若当前字符不同，编码值较小的字符串更小。例如 "apple" < "banana"（'a'（97） < 'b'（98））。
- 若字符相同，则继续比较下一个字符。
长度影响结果 若两字符串前缀完全相同，较短字符串更小。例如：
- "app" < "apple"（长度 3 < 5）。
- 空字符串 "" 被视为小于任何非空字符串。
大小写敏感性 默认区分大小写，大写字母（如 'A'（65））小于小写字母（如 'a'（97））。例如：
- "Apple" < "apple"（'A' < 'a'）
- "DEF" < "def"（大写字母的 ASCII 值均小于小写字母）。

⚙️ C 风格字符串的比较方法

使用 <cstring> 中的函数：

strcmp(const char* s1, const char* s2)
- 返回负值：s1 < s2
- 返回 0：s1 == s2
- 返回正值：s1 > s2
```
if (strcmp("apple", "banana") < 0) // 结果为真。
```

strncmp(const char* s1, const char* s2, size_t n) 比较前 n 个字符：

strncmp("hello", "helicopter", 3); // 比较 "hel" 和 "hel"，返回 0。

📚 C++ `std::string` 类的比较方法

重载的比较运算符（==, !=, <, >, <=, >=）直接使用运算符，符合字典序规则：
```
std::string s1 = "apple", s2 = "banana";
if (s1 < s2) // 结果为真。
```
compare() 成员函数 支持灵活的子串比较，返回规则同 strcmp()：
```
std::string s = "Hello, world";
s.compare(7, 5, "world"); // 比较 "world" 和 "world"，返回 0。
```
支持多种重载形式：
- 比较整个字符串：s1.compare(s2)
- 比较子串：s1.compare(pos1, len1, s2, pos2, len2)

⚠️ 注意事项

不区分大小写的比较 需手动转换字符串为统一大小写：

#include <cctype>
std::string s1 = "Apple", s2 = "apple";
auto lower = [](std::string s) {
    for (char& c : s) c = std::tolower(c);
    return s;
};
if (lower(s1) == lower(s2)) // 相等。

边界安全 使用 strncmp 或 compare() 时需确保范围不越界。
数值字符串比较 "123" > "45"（字典序）但数值 123 > 45，需用 std::stoi 转换后比较。

💎 总结

场景	规则
字符不同	编码值小的字符串更小（如 `"a" < "b"`）
字符相同但长度不同	较短的字符串更小（如 `"app" < "apple"`）
大小写敏感	大写字母 < 小写字母（如 `"A" < "a"`）

根据需求选择：

简洁性 → std::string 的运算符（如 s1 < s2）。
灵活性 → compare() 或 strncmp（支持子串比较）。
忽略大小写 → 预处理转换为统一大小写。

移动语义

std::move 是 C++11 引入的核心工具，用于触发移动语义（Move Semantics），通过资源所有权转移而非复制来提升性能。以下是其核心要点及使用场景：

🔧 本质与原理

类型转换工具
- std::move 将左值强制转换为右值引用（T&&），表明该对象可被“移动”。
- 注意：它本身不执行任何移动操作，仅改变类型标识，真正的移动由移动构造函数/赋值运算符实现。
- 原型：
```
template <class T> 
constexpr typename std::remove_reference<T>::type&& move(T&& t) noexcept;
```
移动语义的核心

 资源窃取

 ：移动构造函数或赋值运算符直接接管原对象的资源（如动态内存、文件句柄），避免深拷贝。

 ```
 // 移动构造函数示例
 MyString(MyString&& other) noexcept : data(other.data) {
     other.data = nullptr;  // 原对象资源置空
 }
 ```

性能提升：对 std::vector、std::string 等资源密集型对象，移动成本为 O(1)，而拷贝为 O(n)。

🚀 典型应用场景

容器操作优化
- 向容器插入大对象时，用

     std::move
     ```

避免拷贝：

     ```
     std::vector<std::string> vec;
     std::string s = "Hello";
     vec.push_back(std::move(s));  // 移动而非拷贝，s 变为空
     ```

2. **资源所有权转移**

   - 适用于独占型资源管理类（如

 std::unique_ptr
 ```

 ）：

 ```
 auto ptr1 = std::make_unique<int>(42);
 auto ptr2 = std::move(ptr1);  // ptr1 变为 nullptr
 ```

函数返回值优化
- 返回局部对象时，编译器可能自动使用移动语义（RVO/NRVO），显式用

     std::move
     ```

可确保移动：

     ```
     std::vector<int> createVector() {
         std::vector<int> tmp;
         return std::move(tmp);  // 强制触发移动（C++17 后通常无需显式调用）
     }
     ```



------

### ⚠️ **关键注意事项**

1. **原对象状态失效**

   - 被移动后的对象处于**有效但未定义状态**（如 `std::vector` 的 `size()` 可能为 0）。

   - 

     禁止再访问资源

     ：

     ```
     std::string s1 = "text";
     std::string s2 = std::move(s1);
     std::cout << s1.size();  // 未定义行为！可能输出 0 或崩溃
     ```

2. **移动语义需显式实现**

   - 若类未定义移动构造函数/赋值运算符，`std::move` 会退化为拷贝操作。
   - **标记 `noexcept`**：确保移动操作不会抛出异常，避免 STL 容器扩容时回退到拷贝。

3. **禁用场景**

   - **

     ```
     const
     ```

对象**：无法移动（移动操作需修改原对象）：

     ```
     const std::string s = "immutable";
     auto s2 = std::move(s);  // 实际触发拷贝！
     ```

   - **小型对象**（如 `int`、`char`）：移动与拷贝开销相同，无需使用。



------

### 💎 **拷贝 vs 移动对比**

| **特性**       | **拷贝语义**            | **移动语义**            |
| -------------- | ----------------------- | ----------------------- |
| **资源操作**   | 深拷贝（复制资源）      | 资源转移（窃取资源）    |
| **性能**       | 高开销（O(n) 内存复制） | 低开销（O(1) 指针交换） |
| **原对象状态** | 不变                    | 有效但未定义            |
| **适用对象**   | 所有类型                | 支持移动构造/赋值的类型 |
| **语法示例**   | `v2 = v1;`              | `v2 = std::move(v1);`   |



------

### ⚡ **最佳实践**

1. **明确所有权转移意图**：仅对不再使用的对象使用 `std::move`。
2. **优先依赖编译器优化**：函数返回值尽量依赖 RVO（返回值优化），而非显式 `std::move`。
3. **验证移动支持**：自定义资源管理类需实现移动构造函数/赋值运算符。

> **移动的本质是“资源窃取许可证”** —— 它授权目标对象接管原对象的资源，但需确保原对象不再被依赖。合理使用可显著提升程序性能，尤其在处理容器、智能指针或大型数据结构时。

## auto 语义

“error: variable 'construct' declared with deduced type 'auto' cannot appear in its own initializer” 是 C++ 编译器的类型推导错误，表示 **变量在初始化表达式中引用了自身**，导致编译器无法推导出该变量的类型。以下是详细分析和解决方案：



------

### ⚠️ **错误原因**

`auto` 类型推导依赖**初始化表达式**在编译时确定变量类型。若变量在初始化表达式中引用自身，会形成**循环依赖**：

auto construct = construct + 1; // 错误！初始化时引用了自身


编译器在推导 `construct` 的类型时，发现其初始化表达式包含 `construct` 自身，此时 `construct` 的类型尚未确定，导致推导失败。



------

### 🔧 **解决方法**

#### **拆分声明与初始化**

将变量声明和初始化分离，先声明变量再赋值（需明确指定类型）：

int construct; // 显式声明类型 construct = construct + 1; // 后续赋值（注意：此处逻辑可能仍有问题）


**注意**：若初始化依赖自身值（如 `construct = construct + 1`），逻辑本身是错误的，因为未初始化的变量值是未定义的（UB）。

#### **显式指定变量类型**

若初始化表达式需依赖其他变量，直接指定类型而非使用 `auto`：

int x = 10; int construct = x + 1; // 显式指定 int 类型


#### **避免循环依赖的初始化**

重构代码，确保初始化表达式**不引用当前声明的变量**：

auto value = 42; // 合法：初始化表达式是字面量 auto result = value * 2; // 合法：依赖已定义的 value




------

### ⚠️ **其他常见 `auto` 错误场景**

1. **未初始化变量**
   `auto` 变量必须初始化，否则编译器无法推导类型：

auto x; // ❌ 错误：declaration of ‘auto x’ has no initializer


2. **与旧版 C++ 的 `auto` 混淆**
在 C++11 前，`auto` 表示“自动存储期”（如 `auto int b=0;`）。C++11 起该用法被废弃，组合使用会报错：

auto int x = 10; // ❌ 错误：auto 不能与其他类型说明符组合


3. **初始化表达式类型不明确**
若初始化表达式类型不一致或为空，推导失败：

auto a = {1, 2.5}; // ❌ C++14 前错误：无法推导统一类型 auto b; // ❌ 未初始化




------

### 💡 **最佳实践**

1. **确保初始化表达式独立**：
初始化表达式应仅依赖**已定义变量**或**字面量**，避免自引用。
2. **复杂场景显式指定类型**：
若类型推导可能歧义（如多类型表达式），优先显式声明类型。
3. **检查循环逻辑**：
自引用初始化通常是逻辑错误，需重新设计变量初始化流程。



------

### 📝 **修正案例**

// 错误示例 auto construct = construct * 2; // ❌ 自引用 // 修正方案1：显式指定类型 int construct = 10; // 先初始化 construct = construct * 2; // 再赋值 // 修正方案2：拆分步骤 int init_value = 10; // 定义初始值 auto construct = init_value * 2; // ✅ 依赖已定义的 init_value


> 提示：在 Visual Studio 等 IDE 中，可通过编译器选项 `/Zc:auto` 强制使用 C++11 的 `auto` 语义，避免与旧版混淆。

## 匿名函数

在C++中，匿名函数（即Lambda表达式）的类型是由编译器自动生成的**唯一闭包类型（closure type）**。这一类型具有以下核心特性：

### 🔍 **闭包类型（Compiler-Generated Closure Type）**

- 每个Lambda表达式在编译时都会生成一个**匿名、唯一的类类型**，该类重载了`operator()`以实现函数调用语义。
- 该类型的具体名称由编译器内部定义，程序员无法显式声明或直接使用（如`decltype(lambda)`可获取类型，但无法显式写出类型名）。

### ⚙️ **使用 `auto` 声明变量**

- 因闭包类型名称不可知，通常用

auto


声明Lambda的变量：

auto lambda = [](int a, int b) { return a + b; };


此处

lambda


的类型即为编译器生成的闭包类型。

### 🔄 **隐式转换为函数指针（无捕获时）**

- 若Lambda

未捕获任何外部变量

（即捕获列表为

[]


），它可隐式转换为

普通函数指针

：

int (*funcPtr)(int, int) = [](int a, int b) { return a + b; };


此时类型为

int (*)(int, int)


。

### 📦 **`std::function` 包装器**

- 为统一处理不同类型的Lambda，可使用

std::function


包装：

#include std::function<int(int, int)> func = [](int a, int b) { return a + b; };

std::function


可存储任意可调用对象（包括带捕获的Lambda），但会引入轻微运行时开销。

### 🧩 **C++14 的泛型Lambda**

- C++14 支持泛型Lambda，参数类型可为

auto

：

auto generic = [](auto x, auto y) { return x + y; };


此时闭包类型的

operator()


是

模板函数

，类型仍唯一但支持多类型参数。



------

### 💎 总结：Lambda类型特性对比表

| **场景**                 | **Lambda类型**                    | **是否可显式声明** | **典型声明方式**        | **支持捕获** |
| ------------------------ | --------------------------------- | ------------------ | ----------------------- | ------------ |
| **无捕获**               | 函数指针（如 `int(*)(int, int)`） | ✅                  | `函数指针类型`          | ❌            |
| **有捕获**               | 唯一闭包类型                      | ❌                  | `auto`                  | ✅            |
| **需统一接口存储**       | `std::function`                   | ✅                  | `std::function<签名>`   | ✅            |
| **泛型Lambda（C++14+）** | 模板化的闭包类型                  | ❌                  | `auto`（参数含 `auto`） | ✅            |

### ⚠️ 注意事项

- **避免默认捕获**：`[=]`或`[&]`可能引发悬空引用或性能问题，推荐显式指定捕获变量。
- **生命周期管理**：按引用捕获的变量需确保其生命周期长于Lambda。

通过理解Lambda的闭包类型本质，可更安全地用于回调、STL算法（如`std::sort`）等场景，提升代码的简洁性与表现力。

## 捕获方式

在C++的Lambda表达式中，捕获方式决定了外部变量的访问规则。`[=]`（隐式值捕获）、`[&]`（隐式引用捕获）和**明确指定捕获变量**（如`[x, &y]`）各有优缺点和使用场景。以下是详细对比分析：



------

### 📊 **捕获方式对比**

| **特性**         | **`[=]`（隐式值捕获）**                         | **`[&]`（隐式引用捕获）**                  | **明确指定捕获（如`[x, &y]`）**                       |
| ---------------- | ----------------------------------------------- | ------------------------------------------ | ----------------------------------------------------- |
| **捕获规则**     | 自动捕获所有**外部变量的副本**                  | 自动捕获所有**外部变量的引用**             | 仅捕获**显式列出的变量**，可混合值/引用捕获           |
| **修改权限**     | 内部不可修改（需`mutable`修饰）                 | 内部可直接修改原变量                       | 值捕获变量不可修改（需`mutable`），引用捕获可直接修改 |
| **生命周期依赖** | 不依赖原变量（拷贝发生在创建时）                | 依赖原变量生命周期（可能悬空引用）         | 部分依赖（引用捕获需确保原变量有效）                  |
| **典型用例**     | 只读访问外部变量，避免副作用                    | 需修改外部变量或避免拷贝开销               | 精确控制捕获范围，避免隐式捕获的风险                  |
| **风险**         | 拷贝开销大（大型对象）；`mutable`修改不影响外部 | 悬空引用（如Lambda生命周期长于捕获的变量） | 需手动管理变量列表，但风险可控                        |



------

### ⚙️ **关键差异详解**

#### **(1) 变量修改与`mutable`**

- **

[=]


**：

值捕获的变量默认是

const


，修改需加

mutable


，且修改仅影响Lambda内部的副本：

int x = 10; auto lambda = = mutable { x++; }; // 修改内部副本，外部x仍为10


- **

[&]


**：

引用捕获可直接修改原变量：

int y = 20; auto lambda = & { y++; }; // 修改外部y为21


- 

明确指定捕获

：

可自由组合值/引用捕获，灵活性高：

int a = 5, b = 15; auto lambda = a, &b { b += a; }; // a值捕获只读，b引用捕获可修改


#### **(2) 生命周期与悬空引用**

- **

[&]


的高风险场景**：

若Lambda被传递到外部（如异步线程），而捕获的局部变量已销毁，会导致未定义行为：

std::function<int()> create_danger() { int local = 42; return [&] { return local; }; // 危险！返回时local已销毁 } auto func = create_danger(); func(); // 悬空引用！


- **

[=]


和明确指定捕获**：

值捕获的变量不依赖原对象生命周期，但若捕获指针（如

this


或指针变量），仍可能悬空：

class Widget { int data = 100; auto get_handler() { return [=] { return data; }; // 实际捕获this指针，Widget销毁后失效 } }; // 解决方案：用初始化捕获[data=data]


#### **(3) 性能与开销**

- **`[=]`**：
可能引发不必要的拷贝（如大型对象），但安全。
- **`[&]`**：
无拷贝开销，但需警惕悬空引用。
- **明确指定捕获**：
优化性能的关键：对小型对象值捕获，大型对象或需修改时引用捕获（确保生命周期安全）。



------

### 🛡️ **最佳实践与推荐**

1. **避免隐式捕获（`[=]`/`[&]`）**：

 - 隐式捕获易导致意外行为（如误捕不需要的变量或悬空引用）。
 - 优先使用**显式捕获列表**（如`[x, &y]`），明确意图并减少风险。

2. **C++14+ 使用初始化捕获**：

 - 支持闭包内变量自定义初始化，避免悬空引用：

   ```
   auto ptr = std::make_shared<int>(42);
   auto lambda = [ptr] { return *ptr; };  // 共享所有权，安全
   ```

 - 可移动捕获大型对象：

   ```
   std::vector<int> large_data;
   auto lambda = [data = std::move(large_data)] { ... };  // 零拷贝
   ```

3. **引用捕获的适用场景**：

 - 需修改外部变量（如累加器）。
 - 对象不可拷贝（如`std::unique_ptr`）且生命周期可控时。
 - **必须确保Lambda生命周期 ≤ 被捕获变量**。

4. **值捕获的适用场景**：

 - 小型内置类型（如`int`、`double`）。

 - 需要快照数据（如循环计数器

   ```
   i
   ```

   ）：

   ```
   for (int i = 0; i < 5; i++) {
       threads.emplace_back([i] { ... });  // 每个线程捕获独立的i
   }
   ```



------

### 💎 **总结**

| **场景**               | **推荐方式**                          | **原因**                 |
| ---------------------- | ------------------------------------- | ------------------------ |
| 只读访问小型变量       | 显式值捕获（`[x]`）                   | 安全且无额外开销         |
| 需修改外部变量         | 显式引用捕获（`[&y]`）                | 直接修改原变量，避免拷贝 |
| 大型对象或资源管理     | 初始化捕获（`[data=std::move(obj)]`） | 零拷贝，所有权清晰       |
| 异步或长生命周期Lambda | 值捕获或`shared_ptr`                  | 避免悬空引用             |

> **黄金准则**：
> ✅ **显式 > 隐式**：明确列出捕获变量，避免`[=]`/`[&]`的模糊性。
> ✅ **生命周期 > 性能**：引用捕获前，100%确认对象生命周期覆盖Lambda。
> ✅ **C++14+优先用初始化捕获**：灵活且安全，尤其适合资源管理场景。

## substr

在C++中，`s.substr()` 是 `std::string` 类的成员函数，用于从原字符串中提取子字符串。其核心功能是根据指定的起始位置和长度截取字符串的特定部分，返回一个新的字符串对象。以下是详细解析：



------

### 📜 **函数原型**

std::string substr(size_t pos = 0, size_t len = npos) const;


- 

  参数

  ：

  - `pos`：子字符串的起始位置（从0开始索引）。默认值为 `0`（字符串开头）。
  - `len`：要提取的字符数量。默认值为 `npos`（特殊常量，表示截取到字符串末尾）。

- **返回值**：新生成的 `std::string` 对象，包含截取的子字符串。



------

### ⚙️ **参数详解与行为规则**

#### **`pos` 的合法性**

- 若 `pos` 等于字符串长度：返回空字符串（`""`）。

- 若 `pos > 字符串长度`：抛出 `std::out_of_range` 异常。

- 

  正确做法

  ：调用前检查

pos


范围：

if (pos <= s.size()) { auto sub = s.substr(pos); } else { // 错误处理 }


#### **`len` 的截断机制**

- 若 `len` 超过从 `pos` 到末尾的字符数：自动截取到末尾。

- 若 `len = 0`：返回空字符串。

- 

示例

：

string s = “Hello”; cout « s.substr(1, 3); // 输出 “ell” cout « s.substr(1, 10); // 输出 “ello”（自动截断）




------

### 🛠️ **基础用法示例**

#### 场景1：默认截取整个字符串

string s = “C++ Programming”; string sub = s.substr(); // 等效于 s.substr(0, npos) cout « sub; // 输出 “C++ Programming”


#### 场景2：从指定位置截取到末尾

string s = “Hello, World!”; string sub = s.substr(7); // 从索引7开始（字符 ‘W’） cout « sub; // 输出 “World!”


#### 场景3：截取固定长度子串

string s = “123abc”; string sub = s.substr(2, 2); // 从索引2开始，截取2个字符 cout « sub; // 输出 “3a”




------

### 🔍 **常见应用场景**

#### **文件路径处理**

提取文件名或扩展名：

// 提取文件名（不含路径） string path = “/usr/bin/gcc”; size_t pos = path.find_last_of(’/’); string filename = (pos != string::npos) ? path.substr(pos+1) : path; // 提取扩展名 string file = “image.jpg”; size_t dot = file.find_last_of(’.’); string ext = (dot != string::npos) ? file.substr(dot+1) : “”; // “jpg”


#### **结构化数据解析**

分割日期字符串：

string date = “2025-07-21”; string year = date.substr(0, 4); // “2025” string month = date.substr(5, 2); // “07” string day = date.substr(8, 2); // “21”


#### **与 `find()` 配合定位子串**

string s = “Error: File not found”; size_t pos = s.find(“File”); if (pos != string::npos) { string errorMsg = s.substr(pos, 12); // “File not found” }




------

### ⚠️ **关键注意事项**

1. 

   异常安全

   ：

   - 始终检查 `pos` 是否越界，避免未捕获的 `std::out_of_range` 异常。

2. 

   性能开销

   ：

   - 返回新字符串对象，可能涉及内存复制（小字符串通常优化）。

3. 

   空字符串处理

   ：

   - 原字符串为空时，`substr()` 返回空字符串。

4. 

   与 `[]` 操作符区别

   ：

   - `s[i]` 返回单个字符的引用，`substr()` 返回新字符串对象。



------

### 🔄 **与其他语言对比**

| **语言**   | **类似方法**              | **差异点**                            |
| ---------- | ------------------------- | ------------------------------------- |
| Python     | `s[start:end]`            | 支持负数索引（如 `s[-3:]`）           |
| Java       | `s.substring(start, end)` | `end` 参数表示结束索引（不包含）      |
| JavaScript | `s.substr(start, len)`    | 支持负数起始索引（如 `s.substr(-3)`） |



------

### 💎 **总结**

- **核心作用**：安全、灵活地提取子字符串，支持动态截取范围。

- 

  最佳实践

  ：

  - 始终校验 `pos` 合法性，避免异常。
  - 结合 `find()` 实现动态定位。
  - 优先显式指定 `len` 避免隐式截断歧义。

- **适用场景**：文件处理、数据解析、日志过滤等需提取文本片段的场景。

> 通过合理使用 `s.substr()`，可显著提升字符串操作的效率和代码可读性，但需时刻警惕边界条件带来的风险。

随机数

🔧 传统方法：rand()与srand()

⚙️ 现代C++11随机数库（<random>）

核心组件

代码示例

📊 常用随机数分布类型

⚠️ 关键实践建议

🎯 应用场景

💎 总结

万能头

🔍 万能头文件是什么？

⚖️ 优缺点分析

✅ 优点

❌ 缺点

🌐 编译器支持情况

🛠️ 适用场景 vs 规避场景

🔧 替代方案

💎 实践建议

📌 总结

快排

🔍 核心原理与指针定义

⚙️ 分区过程与代码实现

左右指针法步骤

快慢指针法步骤

⏱️ 效率与稳定性对比

🎯 适用场景与选择建议

💎 总结

三路快排

🔍 算法思想与核心优势

三路划分原理

核心优势

⚙️ 分区过程与指针操作

指针定义

分区步骤

递归排序

⏱️ 时间复杂度与空间复杂度

🚀 性能优化技巧

🆚 与传统快排的对比

💻 代码实现（C++示例）

🎯 适用场景

💎 总结

单调栈

⚙️ 定义与基本特性

🔍 核心原理与操作机制

维护单调性的流程（以单调递减栈为例）

📊 典型应用场景与问题解析

下一个更大元素（NGE）

接雨水问题

柱状图最大矩形面积

每日温度问题

⚠️ 实现模板与技巧

通用解题步骤：

常见错误：

🚀 进阶应用与优化

💎 总结与学习建议

单调队列

⚙️ 定义与核心特性

🔍 工作原理与操作流程

入队操作（维护单调性）

出队操作（维护窗口范围）

查询操作（获取极值）

操作流程示例（滑动窗口最大值）

📊 典型应用场景

滑动窗口极值问题

动态规划优化

经典问题扩展

⚖️ 实现模板与复杂度

Java 实现（单调递减队列）

C++ 实现（滑动窗口最大值）

时间复杂度与空间复杂度

⚠️ 常见错误与技巧

💎 总结与学习建议

__builtin_popcount

🔍 核心原理与函数定义

函数原型

底层实现机制

⚡ 性能优势与对比

🛠️ 使用场景与示例

位图操作与组合枚举

数学与算法优化

🔧 传统方法：`rand()`与`srand()`

⚙️ 现代C++11随机数库（`<random>`）

`typedef` 的局限性

`using` 的模板别名

📌 `using` 的扩展功能

使用`char`数组（多字节编码）

宽字符类型（`wchar_t`）

🔍 `std::string`字符串的比较

`==`运算符（最常用）

`compare()`函数

📚 C++ `std::string` 类的比较方法