问题所在：#

1
cout << age, pi, grade, isPassed << endl;

这里使用了逗号运算符 ,，它的作用是依次执行每个表达式，但是它返回的只是最后一个表达式的值（在这个例子中是 isPassed），所以 cout 并不会依次输出每个变量。实际上，这段代码并没有按照你的预期执行。

正确的写法：#

你应该将每个输出项分开，使用多个 << 操作符，而不是逗号。正确的写法如下：

1
cout << age << " " << pi << " " << grade << " " << isPassed << endl;

解释：#

• << 是 C++ 中流输出操作符，用于将数据输出到标准输出流（cout）。
• 每次输出一个值时，使用 << 将其连接起来，逐个输出。
• " " 用来在每个输出项之间加一个空格（如果需要的话）。

完整示例：#

1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    int age = 20;
6
    double pi = 3.14159;
7
    char grade = 'A';
8
    bool isPassed = true;
9

10
    // 正确的输出方式
11
    cout << age << " " << pi << " " << grade << " " << isPassed << endl;
12

13
    return 0;
14
}

输出结果：

1
20 3.14159 A 1

在C++中，要注意区分操作符的使用，特别是 << 和 ,，它们的含义是完全不同的！😊

cin >> a >> b; 的作用：#

cin 是 C++ 中标准库 iostream 提供的输入流对象，表示从标准输入流（通常是键盘）获取数据。>> 是流提取运算符，它从 cin 中提取数据并将其存储到对应的变量中。

解释：#

• cin >> a：从标准输入读取一个值，并将其存储到变量 a 中。
• cin >> b：接着从标准输入读取下一个值，并将其存储到变量 b 中。

这样，cin >> a >> b; 的含义是：

1. 首先读取一个整数并存储到 a。
2. 接着读取下一个整数并存储到 b。

为什么要使用 cin >> a >> b; 而不是 cin >> a, b;：#

在你最初写的代码 cin >> a, b; 中，使用了逗号运算符 ,，其效果并不像你预期的那样是一次性输入两个变量。逗号运算符的作用是执行左边的表达式并返回右边的结果，因此：

• cin >> a 会正确地从输入中读取一个值并将其存储到 a 中。
• 然后，逗号运算符会执行 b，但 b 没有被赋值，所以 b 根本不会被读取。

总结：

• cin >> a >> b; 通过连续使用 >> 运算符来依次从标准输入读取多个变量。
• cin >> a, b; 是错误的写法，因为逗号运算符的使用不符合从输入流中提取数据的意图。

iomanip 头文件#

<iomanip> 是 C++ 中一个用于控制输入输出格式的标准库头文件。它提供了一些流操控符，用来设置 cin 和 cout 的输入输出格式。例如，setprecision、fixed、setw 等都属于 iomanip 中的功能。

fixed 和 setprecision 的作用：#

1. fixed：

   • fixed 是一个格式控制符，用于控制浮点数（float 或 double）的输出格式。
   • 使用 fixed 后，输出的浮点数会以 固定小数点格式 显示，而不是使用 科学计数法（如果数值较大或较小时，默认情况下会使用科学计数法）。

   示例：

   1
   float num = 3.1415926535;
   2
   cout << num << endl;   // 默认会以科学计数法输出
   3
   cout << fixed << num << endl;  // 使用 fixed 显示为固定小数点格式

   输出结果：

   1
   cpp复制编辑3.14159   // 默认输出（科学计数法）
   2
   3.141593  // 使用 fixed 输出（固定小数点格式）

   所以 fixed 改变了浮点数的输出形式，让它按照常见的小数形式输出，而不是科学计数法。

2. setprecision(n)：

   • setprecision(n) 用来指定输出的 浮点数精度，即小数点后显示的位数。
   • 如果你在使用 fixed 后调用 setprecision(n)，它会指定 小数点后显示的位数。

   示例：

   1
   cpp复制编辑float num = 3.1415926535;
   2
   cout << fixed << setprecision(3) << num << endl;  // 输出小数点后3位

   输出结果：

   1
   3.142

   这里使用了 setprecision(3) 来控制小数点后面保留 3 位数字。

组合使用：#

• fixed 和 setprecision 可以组合使用，以控制浮点数输出的格式。fixed 用来强制使用固定小数点格式，而 setprecision 用来设置小数位的数量。

示例：

1
cpp复制编辑#include <iostream>
2
#include <iomanip>
3
using namespace std;
4

5
int main() {
6
    float pi = 3.1415926535;
7

8
    // 使用 fixed 和 setprecision 来控制输出
9
    cout << fixed << setprecision(2) << pi << endl;   // 保留2位小数
10
    cout << fixed << setprecision(4) << pi << endl;   // 保留4位小数
11

12
    return 0;
13
}

输出结果：

1
3.14   // 保留2位小数
2
3.1416 // 保留4位小数

总结：#

• fixed：用于将浮点数输出格式化为固定小数点格式，避免使用科学计数法。
• setprecision(n)：用于设置浮点数输出时的精度（即保留的小数位数）。当与 fixed 一起使用时，它控制的是小数点后保留的位数。

常见用法：#

1
#include <iostream>
2
#include <iomanip>  // 包含 iomanip 头文件
3
using namespace std;
4

5
int main() {
6
    double value = 123.456789;
7

8
    // 设置精度并以固定格式显示浮点数
9
    cout << fixed << setprecision(3) << value << endl;  // 输出 123.457
10
    cout << fixed << setprecision(6) << value << endl;  // 输出 123.456789
11

12
    return 0;
13
}

通过这些格式控制符，你可以灵活地控制浮点数的输出格式，使得程序的输出更加精确和可读。

影响代码的可维护性#

全局变量的值可以在任何地方被修改，这会导致代码的可读性下降，使得 函数之间的依赖性增强，难以排查错误。这与封装的初衷是相悖的

多线程环境下，全局变量可能导致数据竞争#

如果多个线程 同时访问和修改 一个全局变量，而没有加锁，就会发生 数据竞争（Race Condition），导致 未定义行为。若非原子操作，就会数据竞争，导致线程之间未能完全实现想要实现的操作

如何避免全局变量的污染？#

1
static int fileScopeVar = 100;  // 仅限当前文件

1
namespace Math {
2
    int value = 10;
3
}
4

5
namespace Physics {
6
    int value = 20;
7
}
8

9
int main() {
10
    cout << Math::value << endl;   // 10
11
    cout << Physics::value << endl; // 20
12
}

1
class Config {
2
public:
3
    static int maxUsers;
4
};
5
int Config::maxUsers = 100;

1. 什么是引用传递？#

在 C++ 中，引用传递（Pass by Reference） 是指在函数参数中使用 引用（&），让函数 直接操作原变量，而不是创建副本。这样可以：

• 避免值传递时的拷贝开销（尤其是对于大对象）
• 允许函数修改原变量

2. 引用传递 vs. 值传递#

3. 引用传递的语法#

1
#include <iostream>
2
using namespace std;
3

4
// 使用引用传递
5
void modify(int &num) {  // num 是原变量的别名
6
    num += 10;  // 直接修改原变量
7
}
8

9
int main() {
10
    int a = 5;
11
    modify(a);  // 传递 a 的引用
12
    cout << "修改后的 a：" << a << endl;  // 输出 15
13
    return 0;
14
}

🔹 说明：

• int &num 表示 num 是 a 的别名。
• 在 modify() 函数内部，修改 num 就是修改 a 本身。

4. 为什么要用引用传递？#

1
#include <iostream>
2
#include <vector>
3

4
using namespace std;
5

6
// 传递 vector 的引用，避免拷贝
7
void printVector(const vector<int> &v) {
8
    for (int num : v) {
9
        cout << num << " ";
10
    }
11
    cout << endl;
12
}
13

14
int main() {
15
    vector<int> numbers = {1, 2, 3, 4, 5};
16
    printVector(numbers);  // 传递引用
17
    return 0;
18
}

1
void doubleValue(int &x) {
2
    x *= 2;  // 直接修改 x
3
}
4

5
int main() {
6
    int num = 10;
7
    doubleValue(num);
8
    cout << num << endl;  // 输出 20
9
}

1
void swap(int &a, int &b) {
2
    int temp = a;
3
    a = b;
4
    b = temp;
5
}
6

7
int main() {
8
    int x = 3, y = 5;
9
    swap(x, y);
10
    cout << x << " " << y << endl;  // 输出 5 3
11
}

5. 常量引用 const &（防止修改）#

如果不希望函数修改变量，又想用引用传递避免拷贝，就用 常量引用 const &。

1
void print(const int &num) {  // 不能修改 num
2
    cout << num << endl;
3
}
4

5
int main() {
6
    int a = 10;
7
    print(a);
8
}

🔹 const int &num

• 传递 a 的引用 不会拷贝，提高效率。
• const 保证 num 不能被修改。

6. 什么时候用引用传递？#

7. 总结#

✅ 引用传递的优势：

• 避免拷贝，提高效率
• 允许修改原变量
• 适用于多个返回值
• 可以使用 const & 防止修改

📌 记住：

• 如果不修改变量，用 const &（提高效率）。
• 如果需要修改变量，用 &。
• 变量较小（int、char）时，用值传递 int x 影响不大。

📌 解析#

1. 为什么用 string 类型？

   • string 是 C++ STL 提供的标准字符串类型，比 C 风格的 char* 更安全、易用。
   • greet 的参数 msg 需要存储字符串，所以 string 是最佳选择。

2. 默认参数 = "Hello, World!"

   • 在 greet(string msg = "Hello, World!") 中，如果调用 greet();，就会使用默认值 "Hello, World!"。
   • 如果调用 greet("Hi, C++!");，msg 取 "Hi, C++!"，默认值被覆盖。

✅ 解决方案：优化 Fibonacci 计算#

1
#include <iostream>
2
using namespace std;
3

4
const int N = 100;  // 足够大的缓存数组
5
int memo[N] = {0};  // 初始化所有值为 0
6

7
int fib(int n) {
8
    if (n == 0) return 0;
9
    if (n == 1) return 1;
10
    if (memo[n] != 0) return memo[n];  // 如果已计算，直接返回
11
    return memo[n] = fib(n - 1) + fib(n - 2);
12
}
13

14
int main() {
15
    cout << fib(10) << endl; // 输出 55
16
}

🌟 new / delete（动态内存管理）#

C++ 允许在运行时动态分配和释放内存，避免数组大小的固定限制。

📌 动态分配单个变量

1
int *p = new int(10);  // 分配一个 int，值为 10
2
delete p;  // 释放内存
3
p = nullptr;  // 避免野指针

📌 动态分配数组

1
int *arr = new int[5];  // 分配 5 个 int
2
delete[] arr;  // 释放数组

🔹 new 分配的内存必须 delete 释放，否则会内存泄漏！

🌟 示例#

1
#include <iostream>
2
using namespace std;
3

4
int main() {
5
    int x;
6
    cout << "请输入数组大小: ";
7
    cin >> x;
8

9
    int *arr = new int[x];  // 使用变量 x 分配动态数组

📌 注意事项

1. 动态数组的大小可以是变量，不像 C++98 之前的静态数组，必须用常量定义大小。
2. 一定要 delete[] arr;，否则会 内存泄漏（Memory Leak）！
3. C++ 推荐使用 std::vector 代替原生指针数组，因为 vector 会自动管理内存。

🌟 vector<int> 替代动态数组（推荐）#

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
int main() {
6
    int x;
7
    cout << "请输入数组大小: ";
8
    cin >> x;
9

10
    vector<int> arr(x);  // 使用 vector 自动管理内存

✅ std::vector<int> 更安全、更推荐，不用担心 new/delete 造成的内存管理问题！🚀

🌟 基本语法#

1
for (元素类型 变量名 : 容器) {
2
    // 对变量名进行操作
3
}

✅ 特点

• 无需使用索引，避免手动写 i = 0; i < n; i++
• 自动取出容器内的元素，简化代码
• 只能用于 遍历所有元素，无法修改数组大小

🌟 示例 ：修改 vector（必须加 &）#

默认情况下，范围 for 传递的是拷贝，如果你想修改 vector 里的值，必须使用 引用 &：

1
#include <iostream>
2
#include <vector>
3
using namespace std;
4

5
int main() {
6
    vector<int> arr = {1, 2, 3, 4, 5};
7

8
    // 用引用 & 遍历并修改元素
9
    for (int &x : arr) {
10
        x *= 2;  // 所有元素变成 2 倍，取地址后，x直接修改即可，类似引用（别名），而不是
11
    }

🌟 C++ 中 std::string 的用法详解 ++#

++std::string 是 C++ 标准库中的字符串类型，相比 C 风格字符串（char[]），它 更安全、更灵活、更易用，支持动态长度、字符串拼接、查找、子串操作等。

✅ 特点： 可以直接赋值，不像 char[] 需要 strcpy 支持 + 拼接，不像 char[] 需要 strcat 自动管理内存，不会像 char[] 那样容易越界

cin读取单个单词#

1
string name;
2
cout << "请输入你的名字：";
3
cin >> name;  // 只读取一个单词，遇到空格停止

✅ 注意： cin 读取单个单词，遇到空格会停止输入。

getline(cin, string) 读取一整行内容#

1
string sentence;
2
cout << "请输入一句话：";
3
getline(cin, sentence);  // 读取整行，包括空格

📌 cin 读取 int 之后再 getline() 读取字符串，为什么会跳过输入？ 💡 问题的根源 在 C++ 里，cin 读取 整数（如 int）时 不会读取换行符 \n，但 getline(cin, str) 会读取整行（包括换行符）。 因此，如果先用 cin >> 读取 int，再用 getline() 读取字符串，就可能发生“跳过输入” 的问题。

1
#include <iostream>
2
#include <string>
3
using namespace std;
4

5
int main() {
6
    int age;
7
    string name;
8

9
    cout << "请输入你的年龄：";
10
    cin >> age;  // 读取 int，但换行符仍留在输入缓冲区
11

12
    cout << "请输入你的名字：";
13
    getline(cin, name);  // 直接读取输入缓冲区的换行符，导致 name 变为空字符串
14

15
    cout << "年龄：" << age << ", 姓名：" << name << endl;
16
    return 0;
17
}

✅ 解决方案：使用 cin.ignore() cin.ignore() 用于丢弃输入缓冲区中的字符，避免 getline() 读取残留的换行符。

1
#include <iostream>
2
#include <string>
3
using namespace std;
4

5
int main() {
6
    int age;
7
    string name;
8

9
    cout << "请输入你的年龄：";
10
    cin >> age;
11
    cin.ignore();  // 清除输入缓冲区中的换行符
12

13
    cout << "请输入你的名字：";
14
    getline(cin, name);  // 这次 getline() 就能正确读取整行了
15

16
    cout << "年龄：" << age << ", 姓名：" << name << endl;
17
    return 0;
18
}

📌 cin.ignore() 详解 cin.ignore(n, char) 丢弃输入缓冲区中的字符，常用两种方式：

cin.ignore()（默认 n=1）：丢弃一个字符（通常是 \n）。 cin.ignore(100, ‘\n’)：最多丢弃 100 个字符，直到遇到 \n（保证清空缓冲区）。 一般来说，cin.ignore() 就足够清除 \n 了，但如果有未知的额外输入，可以用 cin.ignore(100, ‘\n’)。

cout << s.length() << endl;
cout << s.size() << endl; size和length等价

字符串比较：按字典序。从第一个字符开始比较

1
string s = "Hello World";
2
int pos = s.find("World");  // 查找 "World" 的位置
3
if (pos != string::npos) {
4
    cout << "找到 'World'，位置：" << pos << endl;
5
}

1
string s = "Hello World";
2
string sub = s.substr(6, 5);  // 从索引 6 开始，取 5 个字符
3
cout << sub << endl;  // World

1
string s = "Hello World";
2
s.erase(5, 1);  // 删除索引 5 位置的 1 个字符（去掉空格）
3
cout << s << endl;  // HelloWorld
4

5
s.insert(5, " ");  // 在索引 5 插入空格
6
cout << s << endl;  // Hello World
7

8
s.replace(6, 5, "C++");  // 从索引 6 开始的 5 个字符替换成 "C++"
9
cout << s << endl;  // Hello C++

1️⃣ ++it vs. it++ 的区别#

2️⃣ ++it 更高效的原因#

对于内置类型（如 int，char），++it 和 it++ 差别不大，因为它们的递增操作代价几乎相同。

但对于迭代器（如 std::vector<int>::iterator）或自定义对象：

• it++（后置递增） 需要创建一个临时副本，返回原始值，增加额外开销。
• ++it（前置递增） 直接递增，不创建副本，更高效。

1
Iterator operator++(int)  // 后置递增
2
{
3
    Iterator temp = *this;  // 复制当前迭代器
4
    ++(*this);              // 递增当前迭代器
5
    return temp;            // 返回旧值
6
}

1
Iterator& operator++()  // 前置递增
2
{
3
    // 直接递增当前迭代器，不创建临时副本
4
    ++(*this);
5
    return *this;
6
}

🎯 总结#

1️⃣ 反向迭代器的基本用法#

在 C++ 中，标准容器（如 std::vector、std::string、std::list 等）都提供了反向迭代器，其表示方法是：

• rbegin() —— 指向容器的最后一个元素
• rend() —— 指向容器第一个元素的前一个位置

1
#include <iostream>
2
#include <string>
3

4
using namespace std;
5

6
int main()
7
{
8
    string str = "hello";
9

10
    // 使用反向迭代器遍历字符串
11
    for (auto it = str.rbegin(); it != str.rend(); ++it)
12
    {
13
        cout << *it;
14
    }
15
    cout << endl;
16

17
    return 0;
18
}

1
olleh

2️⃣ 反向迭代器 vs 正向迭代器#

1
#include <iostream>
2
#include <vector>
3

4
using namespace std;
5

6
int main()
7
{
8
    vector<int> v = {1, 2, 3, 4, 5};
9

10
    cout << "正向遍历: ";//对比熟悉一下这两个语法
11
    for (auto it = v.begin(); it != v.end(); ++it)
12
        cout << *it << " ";
13
    cout << endl;
14

15
    cout << "反向遍历: ";
16
    for (auto it = v.rbegin(); it != v.rend(); ++it)
17
        cout << *it << " ";
18
    cout << endl;
19

20
    return 0;
21
}

1
#include <iostream>
2
#include <string>
3
#include <algorithm>
4

5
using namespace std;
6

7
int main()
8
{
9
    string str = "hello";
10

11
    reverse(str.begin(), str.end());  // 直接翻转字符串
12
    cout << str << endl;  // 输出 "olleh"
13

14
    return 0;
15
}

🚀 reverse() 方法详解#

reverse() 是 C++ STL（标准模板库）中的一个函数，用于原地反转一个范围（如数组、vector、string等）。

📌 1. reverse() 的基本用法#

1
void reverse(BidirectionalIterator first, BidirectionalIterator last);

📌 2. reverse() 反转数组#

1
#include <iostream>
2
#include <algorithm>
3

4
using namespace std;
5

6
int main()
7
{
8
    int arr[] = {1, 2, 3, 4, 5};
9
    int n = sizeof(arr) / sizeof(arr[0]);
10

11
    reverse(arr, arr + n);  // 反转整个数组
12

13
    for (int i = 0; i < n; i++)
14
        cout << arr[i] << " ";
15

16
    return 0;
17
}

传入需要反转的数组范围的首、末地址

reverse() 函数不仅可以反转整个数组，还可以反转数组的部分。你只需要指定要反转的范围，即传入两个迭代器（或指针），它们分别指向反转部分的开始和结束位置。

只要框定范围就可以。注意是左闭右开的

1
reverse(arr + 2, arr + 5);  // 反转 arr[2] 到 arr[4]

+2 +5是指针的，移位加法s

📌 3. reverse() 反转 vector#

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
using namespace std;
6

7
int main()
8
{
9
    vector<int> vec = {10, 20, 30, 40, 50};
10

11
    reverse(vec.begin(), vec.end());  // 反转整个 vector。左闭右开，则end()恰好指向的是最后一个元素的后一个位置
12

13
    for (int num : vec)
14
        cout << num << " ";
15

16
    return 0;
17
}

📌 4. reverse() 反转 string#

📌 5. reverse() 反转部分元素#

你也可以只反转一部分范围。注意范围的确定是前包含后不包含的即可，左闭右开。

📌 6. 使用 reverse() 结合 rbegin() 和 rend()#

如果想反转整个容器，你也可以用反向迭代器 rbegin() 和 rend()：

1
#include <iostream>
2
#include <vector>
3
#include <algorithm>
4

5
using namespace std;
6

7
int main()
8
{
9
    vector<int> vec = {10, 20, 30, 40, 50};
10

11
    reverse(vec.rbegin(), vec.rend());  // 反转整个 vector
12

13
    for (int num : vec)
14
        cout << num << " ";
15

16
    return 0;
17
}

🔹 输出

1
50 40 30 20 10

✅ 用 rbegin() 和 rend() 效果和 reverse(vec.begin(), vec.end()) 一样，但更直观。

呃但我感觉意义不明

📌 7. reverse() 与 reverse_copy() 的区别#

土法，new&delete#

1
#include <iostream>
2

3
using namespace std;
4

5
int main()
6
{
7
    int rows = 3, cols = 3;
8

9
    // 创建一个指针数组（每个指针指向一行）
10
    int **a = new int *[rows];
11

12
    // 为每一行分配内存
13
    for (int i = 0; i < rows; i++)
14
        a[i] = new int[cols];
15

16
    // 释放内存（必须先释放行，再释放指针数组）
17
    for (int i = 0; i < rows; i++)
18
        delete[] a[i];
19
    delete[] a;
20

21
    return 0;
22
}

优化：std::vector#

1
vector<vector<int>> a(rows, vector<int>(cols));

• vector<vector<int>> a(rows, vector<int>(cols));

  • 直接创建一个 rows × cols 大小的二维数组，自动管理内存，不需要 new/delete。

• 自动释放内存

  • vector 在超出作用域后会自动释放内存，不需要手动 delete[]。

方法 1：使用 new 时加 () 进行值初始化#

1
int *tag = new int[len]();  // 这样会把所有元素初始化为 0

✔ 适用于 动态分配的数组，保证所有元素都变成 0。

方法 2：使用 std::fill 填充 0#

1
#include <algorithm>
2
int *tag = new int[len];  // 这里不会初始化为 0
3
std::fill(tag, tag + len, 0);  // 手动填充 0

✔ 适用于任意情况，可以填充任意值，不局限于 0。

方法 3：使用 memset 填充 0#

1
#include <cstring>
2
int *tag = new int[len];  // 这里不会初始化为 0
3
memset(tag, 0, sizeof(int) * len);

⚠ memset 只适用于填充 0，不能用于填充非 0 值，否则可能会导致错误。

方法 4：改用 std::vector#

如果不一定要使用裸指针，建议使用 std::vector：

1
#include <vector>
2
std::vector<int> tag(len, 0);  // 直接初始化为 0

✔ 自动管理内存，不会有内存泄漏问题，推荐使用！🎯

✅ 空 vector（无元素）#

1
std::vector<int> pairs;

✅ 指定大小并用默认值（0）填充#

1
std::vector<int> pairs(5);  // 创建一个含有5个0的 vector

✅ 指定大小和初始值#

1
std::vector<int> pairs(5, 42);  // 创建一个含有5个42的 vector

✅ 使用列表初始化#

1
std::vector<int> pairs = {1, 2, 3, 4, 5};

✅ 使用 std::fill（或其他算法）#

1
std::vector<int> pairs(5);
2
std::fill(pairs.begin(), pairs.end(), 7);  // 把所有元素设为7

✅ 复制另一个 vector#

1
std::vector<int> other = {1, 2, 3};
2
std::vector<int> pairs(other);  // 拷贝构造

✅ 使用 push_back() 添加单个元素#

1
std::vector<int> pairs;
2
pairs.push_back(10);
3
pairs.push_back(20);
4
pairs.push_back(30);

这会将 10, 20, 30 按顺序加到 vector 末尾。

✅ 使用 emplace_back()（性能更优一点）#

1
pairs.emplace_back(40);

✅ 插入多个元素：insert()#

1
std::vector<int> more = {50, 60, 70};
2
pairs.insert(pairs.end(), more.begin(), more.end());

✅ 添加整个数组或列表#

1
pairs.insert(pairs.end(), {80, 90, 100});

✅ 情况1：能找到刚好等于或大于 success 的值#

1
std::vector<int> temp = {1, 3, 5, 7, 9};
2
int success = 5;

• lower_bound 找的是第一个 >= 5 的值。
• 5 在索引 2 处，所以：

1
index = 2;

✅ 情况2：所有元素都小于 success#

1
std::vector<int> temp = {1, 2, 3};
2
int success = 10;

• 没有元素 >= 10，lower_bound 返回的是 temp.end()。
• 所以：

1
index = 3; // 即 temp.size()

✅ 情况3：所有元素都 >= success#

1
std::vector<int> temp = {10, 20, 30};
2
int success = 5;

• 第一个 >= 5 的是 10，在索引 0：

1
index = 0;

✅ 情况4：有多个相同的元素（等于 success）#

1
std::vector<int> temp = {1, 3, 5, 5, 5, 7};
2
int success = 5;

• lower_bound 会返回第一个 5 的位置 → 索引 2：

1
index = 2;

✅ 情况5：success 小于最小值#

1
std::vector<int> temp = {4, 5, 6};
2
int success = 1;

• lower_bound 返回第一个大于等于 1 的 → 索引 0：

1
index = 0;

🔁 总结表格：#

语法：#

1
auto it = std::lower_bound(nums.begin() + index, nums.end(), value);

nums.begin()是第0号，+index就刚好是当前的这个数

解释：#

• nums.begin() + i + 1 是 从当前索引 i 的下一个元素开始，也就是从 nums[i+1] 开始。
• lower_bound() 会在这个范围内查找 第一个大于或等于 target2 的元素。

代码解析：#

1
int index1 = distance(nums.begin(), lower_bound(nums.begin() + i + 1, nums.end(), target2));

• lower_bound(nums.begin() + i + 1, nums.end(), target2) 计算 从 i + 1 开始，直到 nums.end() 范围内第一个 大于或等于 target2 的位置。
• 然后，distance(nums.begin(), ...) 计算 从 nums.begin() 到返回的迭代器的位置的距离，也就是找出目标元素在数组中的索引。

upper_bound() 语法：#

1
std::upper_bound(first, last, value)

• first 和 last：是待查找范围的迭代器（通常是容器的 begin() 和 end()）。
• value：需要查找的目标值。

返回值是一个迭代器，指向 第一个大于 value 的元素。

特点：#

• 如果 value 小于容器中的所有元素，返回的是容器的 begin() 迭代器。
• 如果 value 大于容器中的所有元素，返回的是容器的 end() 迭代器。
• 如果找到了与 value 相等的元素，返回的是 第一个大于 value 的元素。

所以，想要找到小于等于value的最大的那个数，要给upper_bound()的结果减掉1

C++链表#