C++的各种标准库与功能（附源代码）

一、引言

    嗨大家好！今天给大家带来一篇简介C++/C里的内置模块的功能及示例代码！

二、内部库表格

  以下是内部库的表格，有名称，主要函数、以及功能：

库名称	功能	主要函数
iostream	提供基本的输入输出功能	cin, cout, cerr, clog
cmath	数学函数库	sqrt(), sin(), cos(), pow()
cctype	字符处理库	isalpha(), isdigit(), tolower()
string	处理字符串操作	length(), substr(), find()
vector	动态数组容器	push_back(), size(), at()
algorithm	提供各种常用算法	sort(), find(), binary_search()
map	关联容器，键值对	insert(), find(), erase()
fstream	文件输入输出操作	open(), close(), getline()

iomanip	输入输出控制库	setw(), setprecision(), setfill()
ctime	时间库	time(), asctime(), strftime()
bitset	位集库	set(), reset(), test(), flip()
queue	队列库	push(), pop(), front(), empty()
stack	栈库	push(), pop(), top(), empty()
regex	正则表达式库	regex_match(), regex_search(), regex_replace()
random	随机数库	rand(), srand(), uniform_int_distribution, uniform_real_distribution

 注：如果不想写那么多头文件，可以使用万能头：include<bits/stdc++.h>。

以上是C++内置函数表格，下面将列举每个内置库的示例代码。📉📊📈 

 三、示例代码

1、iostream📝📒

输入输出操作，包括标准输入输出、文件流等。一般用于数据输出功能。

以下是示例代码：

#include<iostream>
using namespace std;
int main(){
    int a, b;
    cin >> a >> b;
    cout << a + b;
    return 0;
}

输出结果是a + b的和。注意一定要输入数字。

2、cmath 🧮📄

cmath是C/C++的数学库，主要用于数学计算、统筹规划等数学方面的问题。

  以下是示例代码：

​
#include <iostream>
#include <cmath>

using namespace std;

int main() {
    double x = 1.0;
    
    double sinn = sin(x);
    cout << "sin(" << x << ") = " << sinn << '\n';
    
    double coss = cos(x);
    cout << "cos(" << x << ") = " << coss << endl;
    
    double abss = abs(-5.6);
    cout << "abs(-5.6) = " << abss << endl;
    
    double logg = log(10.0);
    cout << "log(10) = " << logg << endl;
    
    return 0;
}

​

3、cctype📁📊

  cctype一般用于：字符处理，提供了字符类型判断和转换的函数

  以下是示例代码：

#include<iostream>
#include<cctype>
using namespace std;
int main() {
    char ch = 'A';
    cout << "Character: " << ch << endl;

    // 判断字符是否是字母
    if (isalpha(ch)) {
        cout << "是字母" << endl;
    } else {
        cout << "不是字母" << endl;
    }

    // 将字符转换为小写字母
    char lowercaseCh = tolower(ch);
    cout << "转换为小写字母: " << lowercaseCh << endl;

    // 将字符转换为大写字母
    char uppercaseCh = toupper(ch);
    cout << "转换为大写字母: " << uppercaseCh << endl;

    // 判断字符是否是数字
    if (isdigit(ch)) {
        cout << "是数字" << endl;
    } else {
        cout << "不是数字" << endl;
    }

    return 0;
}
/*
输出结果：
Character: A
是字母
转换为小写字母: a
转换为大写字母: A
不是数字
*/

在这个示例程序中，我们使用了 using namespace std;，这样可以直接使用 cout、endl、isalpha()、tolower()、toupper() 和 isdigit()，而无需添加 std:: 前缀。

程序首先定义了一个字符变量 ch，并输出其值。然后使用 isalpha() 函数判断字符是否是字母，并根据判断结果输出相应信息。

接下来，使用 tolower() 函数将字符转换为小写字母，使用 toupper() 函数将字符转换为大写字母，并输出转换后的结果。

最后，使用 isdigit() 函数判断字符是否是数字，并输出相应信息。

4、string🎁🎨

string主要用于字符串操作，如：大小写判断，长度，和翻转等

以下是示例代码：

#include <iostream>
#include <string>

using namespace std;

int main() {
    string str = "Hello, world!";

    cout << "字符串: " << str << endl;

    // 获取字符串长度
    cout << "字符串长度: " << str.length() << endl;

    // 判断字符串是否为空
    if (str.empty()) {
        cout << "字符串为空" << endl;
    } else {
        cout << "字符串不为空" << endl;
    }

    // 字符串连接
    string str2 = " Welcome!";
    string combinedStr = str + str2;
    cout << "连接后的字符串: " << combinedStr << endl;

    // 字符串查找
    size_t found = str.find("world");
    if (found != string::npos) {
        cout << "找到了子字符串 'world'，位置为: " << found << endl;
    } else {
        cout << "未找到子字符串 'world'" << endl;
    }

    return 0;
}
/*
字符串: Hello, world!
字符串长度: 13
字符串不为空
连接后的字符串: Hello, world! Welcome!
找到了子字符串 'world'，位置为: 7

*/

在这个示例程序中，我们使用了 using namespace std;，可以直接使用 cout、endl、string、length()、empty()、+、find() 和 npos

程序首先定义了一个字符串变量 str，并输出其值。使用 length() 函数获取字符串的长度，并输出。

然后使用 empty() 函数判断字符串是否为空，并根据判断结果输出相应信息。

接下来，使用 + 运算符将字符串连接起来，并将结果保存在 combinedStr 变量中。输出连接后的字符串。

最后，使用 find() 函数在字符串中查找子字符串 "world"，并返回其位置。如果找到则输出位置，否则输出未找到的信息。

5、vector📒📚

动态数组，提供了动态大小的数组容器

以下是示例代码：

#include <iostream>
#include <vector>

using namespace std;

int main() {
    // 创建一个空的 vector
    vector<int> nums;

    // 在尾部插入元素
    nums.push_back(1);
    nums.push_back(2);
    nums.push_back(3);

    cout << "向 vector 中插入元素后，元素个数为：" << nums.size() << endl;

    // 遍历并输出 vector 中的元素
    cout << "vector 中的元素：";
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;

    // 修改指定位置的元素
    nums[1] = 4;

    // 删除尾部的元素
    nums.pop_back();

    cout << "修改和删除元素后，元素个数为：" << nums.size() << endl;

    // 再次遍历并输出 vector 中的元素
    cout << "vector 中的元素：";
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;

    return 0;
}
/*
结果：=> 向 vector 中插入元素后，元素个数为：3
vector 中的元素：1 2 3 
修改和删除元素后，元素个数为：2
vector 中的元素：1 4 

*/

在这个示例程序中，我们使用了 using namespace std;，可以直接使用 cout、endl、vector、push_back()、size()、[] 和 pop_back()，而无需添加 std:: 前缀。

程序首先创建一个空的 vector 容器 nums。

然后使用 push_back() 函数向 vector 的尾部依次插入元素 1、2、3。使用 size() 函数获取 vector 中元素的个数，并输出。

接着使用循环遍历并输出 vector 中的元素。

然后使用 [] 运算符修改指定位置的元素，将索引为 1 的元素修改为 4。

再然后使用 pop_back() 函数删除 vector 尾部的元素。

再次使用 size() 函数获取 vector 中元素的个数，并输出。

最后再次使用循环遍历并输出 vector 中的元素。 

6、algorithm🎋🎄

<algorithm> 是 C++ 标准库中的一个头文件，提供了各种算法操作和函数模版，用于处理数据集合。它包含了一组常用的算法，涵盖了搜索、排序、操作、变换等功能，可以方便地对数组、容器等进行各种操作。

以下是 <algorithm> 头文件中一些常用的算法和函数模版的功能：

• 搜索算法：例如 find() 函数用于在容器中查找指定元素，binary_search() 函数用于在已排序的序列中二分查找指定元素。

• 排序算法：例如 sort() 函数用于对容器中的元素进行排序，merge() 函数用于将多个已排序的序列合并为一个有序序列。

• 数值算法：例如 accumulate() 函数用于对序列中的元素进行累加，count() 函数用于计算指定元素在序列中出现的次数。

• 修改算法：例如 fill() 函数用于将指定范围的元素填充为指定值，transform() 函数用于对序列中的元素进行变换并存储到另一个序列中。

• 删除算法：例如 remove() 函数用于删除容器中的指定元素，erase() 函数用于删除容器中满足条件的元素。

• 遍历算法：例如 for_each() 函数用于对序列中的每个元素执行指定操作，copy() 函数用于将一个序列复制到另一个序列。

<algorithm> 头文件中定义的算法和函数模版能够显著简化代码编写过程，提高代码的可读性和维护性。开发者可以根据具体的需求选择合适的算法来对数据进行处理。

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

using namespace std;

int main() {
    vector<int> nums = {5, 2, 8, 1, 9, 3};

    // 使用 sort() 函数对容器中的元素进行排序
    sort(nums.begin(), nums.end());

    cout << "排序后的元素：";
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;

    // 使用 find() 函数查找指定元素
    int target = 8;
    auto it = find(nums.begin(), nums.end(), target);
    if (it != nums.end()) {
        cout << "找到了元素 " << target << " 在位置 " << distance(nums.begin(), it) << endl;
    } else {
        cout << "未找到元素 " << target << endl;
    }

    return 0;
}
/*
排序后的元素：1 2 3 5 8 9
找到了元素 8 在位置 4

*/

这个示例程序首先创建一个 vector 容器 nums，并初始化为 {5, 2, 8, 1, 9, 3}。

然后使用 sort() 函数对容器中的元素进行排序，将它们按升序排列。

接着使用循环遍历并输出排序后的元素。

然后使用 find() 函

上述代码中，我们添加了 using namespace std; 语句，这样就可以直接使用 sin、cos、abs 和 log 等函数，而无需在前面加上 std:: 的前缀。其他部分与之前的示例代码相同。

编译并运行上述代码，输出结果与之前的示例相同。

需要注意的是，尽管使用 using namespace std; 可以简化代码，但也会引入整个 std 命名空间中的所有内容。这可能会导致命名冲突或者不明确的情况。因此，在实际开发中，建议在全局范围内使用更明确的作用域解析运算符（如 std::）来指定标准库中的函数和对象。

数在容器中查找指定元素 8。如果找到该元素，则输出元素的值和它在容器中的位置；如果未找到，则输出未找到的信息。

整个程序演示了如何使用 <algorithm> 头文件中的排序和搜索算法。

7、map🎈🧨

map 是 C++ 标准库中的一个关联容器，它提供了键-值对的存储和访问功能。map 内部使用红黑树实现，可以自动按照键的顺序进行排序，并且支持快速的插入、查找和删除操作。

以下是 map 的一些特点和用法：

• 键值对的存储：map 中的每个元素都是一个键值对，其中键和值可以是任意的数据类型，例如整数、字符串、自定义类型等。

• 自动排序：map 内部会根据键的比较规则自动对键进行排序，默认情况下按照升序进行排序。可以通过自定义比较函数来指定其他的排序规则。

• 唯一键：map 中的键是唯一的，如果插入了已存在的键，则会覆盖原来的值。

• 插入和访问元素：可以使用 insert() 函数向 map 中插入新的键值对，也可以使用 [] 运算符或 at() 函数来访问和修改特定键对应的值。

• 查找元素：可以使用 find() 函数来查找特定键对应的值，如果键不存在，则返回指向末尾的迭代器。也可以使用 count() 函数来统计特定键在 map 中出现的次数。

下面是一个简单的使用 map 的示例代码：

#include <iostream>
#include <map>

using namespace std;

int main() {
    map<int, string> studentMap;

    // 使用 insert() 函数插入键值对
    studentMap.insert(make_pair(101, "Alice"));
    studentMap.insert(make_pair(102, "Bob"));
    studentMap.insert(make_pair(103, "Charlie"));

    // 使用 [] 运算符访问特定键对应的值
    cout << "学生编号 101 对应的姓名为：" << studentMap[101] << endl;

    // 使用 at() 函数访问特定键对应的值
    cout << "学生编号 102 对应的姓名为：" << studentMap.at(102) << endl;

    // 使用 count() 函数统计特定键在 map 中的出现次数
    int key = 103;
    if (studentMap.count(key) > 0) {
        cout << "学生编号 " << key << " 存在" << endl;
    } else {
        cout << "学生编号 " << key << " 不存在" << endl;
    }

    return 0;
}

在这个示例中，我们将 using namespace std; 放在所有头文件的前面，这样可以在整个代码中使用 cout、endl 和 map，而不需要显式指定命名空间。

8、fstream📈📉

  

fstream 是 C++ 中用于文件输入和输出操作的标准库。它提供了一个方便的机制来读取和写入文件中的数据。

fstream 头文件定义了三个类，用于实现不同类型的文件操作：

1. ifstream：用于从文件中读取数据。可以打开文件进行读取操作，并使用输入操作符（>>）从文件中提取数据。
2. ofstream：用于将数据写入文件。可以创建或打开文件进行写入操作，并使用输出操作符（<<）将数据写入文件。
3. fstream：可用于读取和写入文件。它是 ifstream 和 ofstream 的结合，具有同时读取和写入文件的能力。

使用 fstream 进行文件操作的一般步骤如下：

1. 创建一个文件流对象，例如 ifstream、ofstream 或 fstream。
2. 使用 open() 函数打开文件，指定文件名和打开模式（读取、写入、追加等）。
3. 对文件进行读写操作，使用输入操作符（>>）来读取数据，使用输出操作符（<<）将数据写入文件。
4. 在操作完成后，使用 close() 函数关闭文件。

以下是一个简单的示例代码，演示了如何使用 fstream 进行文件读写操作：

#include <fstream>
#include <iostream>

using namespace std;

int main() {
    ofstream outfile("example.txt"); // 创建输出文件流对象

    if (outfile.is_open()) {
        outfile << "Hello, World!" << endl; // 将数据写入文件
        outfile.close(); // 关闭文件
        cout << "文件写入成功。" << endl;
    } else {
        cout << "无法打开文件。" << endl;
    }

    ifstream infile("example.txt"); // 创建输入文件流对象
    string line;

    if (infile.is_open()) {
        while (getline(infile, line)) { // 从文件中逐行读取数据
            cout << line << endl; // 输出到控制台
        }
        infile.close(); // 关闭文件
        cout << "文件读取成功。" << endl;
    } else {
        cout << "无法打开文件。" << endl;
    }

    return 0;
}

这段代码首先创建了一个输出文件流对象 ofstream，然后使用 open() 函数打开名为 "example.txt" 的文件，接着使用 << 操作符将数据写入文件。写入完成后，关闭文件流对象。

然后创建了一个输入文件流对象 ifstream，再次使用 open() 函数打开同一个文件进行读取操作。使用 getline() 函数从文件中逐行读取数据，并输出到控制台。

最后关闭输入文件流对象。

9、iomanip💻📙

iomanip 是 C++ 中用于操作流（包括输入和输出流）的标准库。它提供了一组功能强大的流控制函数，用于格式化输出和处理输入。

iomanip 头文件中定义了各种用于控制流行为和格式的函数、类和操作符。它可以用于设置输出字段宽度、小数位数、对齐方式等，以及设置输入的格式要求。

以下是 iomanip 的一些常用功能：

1. setw(int n)：设置输出字段的宽度为 n。
2. setfill(char c)：设置填充字符为 c。
3. setprecision(int n)：设置输出浮点数的精度为 n。
4. setiosflags(int flags) 和 resetiosflags(int flags)：根据 flags 设置或重置输出格式标志，例如科学计数法、定点表示法等。
5. hex、dec、oct 和 boolalpha 等操纵符：用于改变输出或输入的基数、格式和布尔值的显示方式。
6. setw、setfill 和 setprecision 等函数可以与输出流操作符 << 结合使用，直接在输出语句中应用。
7. noskipws、skipws 等操纵符：用于控制输入时是否跳过空白字符等。

下面是示例代码：

#include <iostream>
#include <iomanip>
using namespace std;
int main() {
    double pi = 3.14159265359;
    int value = 12345;

    cout << "默认输出：" << pi << endl;
    cout << "固定小数位数（6位）：" <<etprecision(6) << pi << endl;
    cout << "科学计数法：" << scientific << pi << endl;
    cout << "十六进制：" << hex << value << endl;
    cout << "字段宽度为10，左对齐：" << setw(10) << left << value << endl;
    cout << "填充字符为'0'，字段宽度为8：" << setfill('0') << setw(8) << value << endl;

    return 0;
}

 输出结果：

默认输出：3.14159
固定小数位数（6位）：3.14159
科学计数法：3.141593e+00
十六进制：3039
字段宽度为10，左对齐：12345     
填充字符为'0'，字段宽度为8：00012345

这个示例演示了使用 iomanip 进行输出格式控制的一些常见用法。您可以根据需要组合和调整这些函数和操作符，以满足特定的输出格式要求。

10、ctime🌏🕐

<ctime> 是 C++ 标准库中的头文件，它提供了与时间和日期相关的函数和类型。该头文件中定义了多个函数用于获取当前时间、处理时间结构、格式化时间等。

以下是 <ctime> 中一些常用的函数和类型：

1. time_t：表示从 1970 年 1 月 1 日到当前时间的秒数，通常用于存储时间值。
2. clock_t：表示 CPU 执行的时钟周期数，通常用于测量程序的执行时间。
3. struct tm：表示时间的结构体，包括年、月、日、时、分、秒等成员变量。
4. time()：返回当前时间的秒数，以 time_t 类型表示。
5. ctime()：将 time_t 类型的时间值转换为一个可读的字符串表示。
6. localtime()：将 time_t 类型的时间值转换为本地时间的 tm 结构体表示。
7. gmtime()：将 time_t 类型的时间值转换为 GMT 时间的 tm 结构体表示。
8. strftime()：将 tm 结构体表示的时间按照指定格式进行格式化。
9. difftime()：计算两个 time_t 类型时间值之间的差异，以秒为单位。

下面是示例代码：

#include <iostream>
#include <ctime>

using namespace std;

int main() {
    // 获取当前时间的秒数
    time_t now = time(nullptr);
    
    // 将时间值转换为字符串表示
    cout << "当前时间：" << ctime(&now);
    
    // 将时间值转换为本地时间
    struct tm* localTime = localtime(&now);
    
    // 格式化输出本地时间
    char buffer[80];
    strftime(buffer, sizeof(buffer), "本地时间：%Y-%m-%d %H:%M:%S", localTime);
    cout << buffer << endl;
    
    // 计算时间差
    time_t otherTime = now - 3600;  // 假设其他时间比当前时间早1小时
    double diff = difftime(now, otherTime);
    cout << "时间差：" << diff << " 秒" << endl;
    
    return 0;
}

结果为：

当前时间：Wed Aug  5 03:49:20 2023

本地时间：2023-08-05 03:49:20
时间差：3600 秒

这个示例演示了 <ctime> 头文件中的一些常用函数的使用方式。您可以根据需要使用这些函数来处理时间和日期，包括获取当前时间、格式化时间、计算时间差等。

11、bitset🔎📕

bitset 是 C++ 标准库中的一个类，用于表示固定大小的二进制位集合。它提供了一种方便的方式来处理和操作二进制数据。

bitset 的特点和用法如下：

1. 大小固定：在创建bitset 对象时，需要指定一个固定的大小（位数），例如 bitset<8> 表示一个包含 8 个位的二进制位集合。

2. 位操作：bitset 提供了一些方法和操作符，可以对二进制数据进行位级操作，包括设置某个位的值、获取某个位的值、翻转位的值等。

3. 位访问：可以通过下标运算符 [] 来访问bitset 中的每个位，并进行读取或设置操作。

4. 迭代器支持：bitset 支持使用迭代器来访问和遍历其中的位。

5. 比较和逻辑操作：bitset 可以进行比较操作（等于、不等于）和逻辑操作（与、或、非、异或）。

6. 数值转换：bitset 支持将二进制位集合转换为其他形式的数值表示，例如整数或字符串。

以下是一个示例，演示了 bitset 的基本用法：

​
#include <iostream>
#include <bitset>
using namespace std;
int main() {
    bitset<8> bits("10101010");

    cout << "Bitset: " << bits << endl;
    cout << "Bit at position 3: " << bits[3] << endl;
    cout << "Number of set bits: " << bits.count() << endl;

    bits.set(2, 1);
    bits.flip();
    
    cout << "Flipped bitset: " << bits << endl;

    return 0;
}

​

  结果：

Bitset: 10101010
Bit at position 3: 0
Number of set bits: 4
Flipped bitset: 01010101

在上述示例中，我们创建了一个大小为 8 的 std::bitset 对象，并使用字符串初始化其值。然后我们输出整个二进制位集合、访问第 3 位的值以及计算设置为 1 的位的数量。之后，我们将第 2 位的值设置为 1，并翻转整个二进制位集合。最后，我们输出翻转后的二进制位集合。

bitset 还提供了许多其他的方法和操作符，例如 reset、test、operator&、operator| 等，可以根据具体需求进行查阅和使用。

12、queue🥽🎑

queue（队列）是C++标准库中的一个容器适配器，用于实现先进先出（FIFO）的数据结构。队列是一种非常常见的数据结构，类似于我们现实生活中的排队场景。

在C++中，队列是通过 queue 模板类来实现的，位于 <queue> 头文件中。它提供了以下常用的操作：

1. push(element): 将 element 添加到队列的末尾。
2. pop(): 移除队列的第一个元素。
3. front(): 返回队列的第一个元素的引用。
4. back(): 返回队列的最后一个元素的引用。
5. empty(): 检查队列是否为空。
6. size(): 返回队列中元素的个数。

队列的特点是，新元素被添加到队列的末尾，而访问和移除元素只能从队列的开头进行，即队首（front）位置。这遵循了先进先出的原则，保证了元素的顺序性。

#include <iostream>
#include <queue>
using namespace std;
int main() {
    // 创建一个整数队列
    queue<int> myQueue;

    // 向队列中添加元素
    myQueue.push(10);
    myQueue.push(20);
    myQueue.push(30);

    // 获取队列的大小
    cout << "队列的大小：" << myQueue.size() << endl;

    // 访问队列的元素（只能访问队首元素，无法直接访问其他位置的元素）
    cout << "队首元素：" << myQueue.front() << endl;

    // 从队列中移除队首元素
    myQueue.pop();

    // 再次访问队首元素
    cout << "队首元素：" << myQueue.front() << endl;

    // 检查队列是否为空
    if (myQueue.empty()) {
        cout << "队列为空" << endl;
    } else {
        cout << "队列不为空" << endl;
    }

    return 0;
}

结果为：

队列的大小：3
队首元素：10
队首元素：20
队列不为空

上述代码首先创建了一个整数队列 myQueue，然后使用push()方法将元素添加到队列中。通过front()和back()方法访问队首和队尾元素。使用pop()方法移除队首元素。最后，使用size()方法获取队列的大小。

13、stack🎪🎢

stack（栈）是C++标准库中的一个容器适配器，用于实现后进先出（LIFO）的数据结构。栈是一种非常常见的数据结构，类似于我们现实生活中的堆叠场景，比如一摞书或者一堆盘子。

在C++中，栈是通过 stack 模板类来实现的，位于 <stack> 头文件中。它提供了以下常用的操作：

1. push(element): 将 element 添加到栈的顶部（栈顶）。
2. pop(): 移除栈顶的元素。
3. top(): 返回栈顶的元素的引用。
4. empty(): 检查栈是否为空。
5. size(): 返回栈中元素的个数。

栈的特点是，新元素被添加到栈的顶部，而访问和移除元素也只能从栈的顶部进行。这遵循了后进先出的原则，保证了元素的顺序性。可以将栈看作是一种具有限制性的线性表。

以下是一个简单示例，展示了如何使用栈：

#include <iostream>
#include <stack>

using namespace std;

int main() {
    stack<int> myStack;

    myStack.push(10);
    myStack.push(20);
    myStack.push(30);

    cout << "栈顶元素：" << myStack.top() << endl;

    myStack.pop();

    cout << "栈顶元素：" << myStack.top() << endl;
    cout << "栈大小：" << myStack.size() << endl;

    return 0;
}

结果：

栈顶元素：30
栈顶元素：20
栈大小：2

上述代码首先创建了一个整数栈 myStack，然后使用push()方法将元素添加到栈顶。通过top()方法访问栈顶元素。使用pop()方法移除栈顶元素。最后，使用size()方法获取栈的大小。

首先，myStack.push(10) 将整数 10 添加到栈顶。 接着，myStack.push(20) 将整数 20 添加到栈顶。 然后，myStack.push(30) 将整数 30 添加到栈顶。

接下来，myStack.top() 返回栈顶元素的值，即 30。 然后，myStack.pop() 移除栈顶元素。 最后，myStack.top() 返回新的栈顶元素的值，即 20。 同时，myStack.size() 返回栈中元素的个数，即 2。

请注意，由于栈是后进先出的数据结构，所以栈顶元素是最后插入的元素，而栈底元素是最先插入的元素。

14、regex🔊🔎

正则表达式（Regular Expression），简称 regex，是一种用于描述字符串模式的表达式语言。它可以帮助我们进行字符串的搜索、匹配、替换、分割和验证等操作。

正则表达式由普通字符（例如字母、数字、标点符号）和特殊字符组成，通过这些字符的组合形成一个规则模式。它可以匹配字符串中具有特定格式、结构或特征的部分。

常见的一些用途包括：

• 搜索：在文本中查找符合特定模式的字符串。
• 匹配：判断一个字符串是否与给定的模式完全匹配。
• 替换：使用正则表达式识别指定模式，并将其替换为新的内容。
• 分割：根据模式将字符串分割成多个部分。
• 验证：验证输入是否符合特定的模式或格式要求。

在C++中，正则表达式功能被集成在 <regex> 头文件中。使用正则表达式需要创建一个 regex 对象，并使用 regex_match、regex_search 等函数来执行匹配操作。

以下是一个示例代码，展示如何使用正则表达式在字符串中查找符合特定模式的子串：

#include <iostream>
#include <regex>

using namespace std;

int main() {
    string text = "Hello, World!";

    // 定义正则表达式模式
    regex pattern("W[a-z]+");

    // 使用 regex_search 进行模式匹配
    if (regex_search(text, pattern)) {
        cout << "模式匹配成功！" << endl;
    } else {
        cout << "模式匹配失败！" << endl;
    }

    return 0;
}

结果：

模式匹配成功！

在上述示例代码中，我们定义了一个字符串 text 和一个正则表达式模式 pattern。然后，我们使用 regex_search 函数对 text 进行模式匹配。

根据给定的模式 "W[a-z]+"，它表示以大写字母 'W' 开头，后面跟着一个或多个小写字母。如果 text 中存在与该模式匹配的子字符串，regex_search 函数将返回 true，否则返回 false。

这意味着字符串 "Hello, World!" 中存在满足模式 "W[a-z]+" 的子字符串。请注意，输出的结果可能因编译器、操作系统和具体输入而有所不同。

15、random👁‍🗨🕑

random库是C++标准库中提供的用于生成伪随机数的库。它提供了各种可以用于生成随机数的函数和工具。

使用random库前，需要包含 <random> 头文件，并通过 using namespace std; 来引入标准命名空间。

下面是一个示例代码，展示如何使用random库生成随机数：

#include <iostream>
#include <random>

using namespace std;

int main() {
    // 创建一个随机数引擎对象
    random_device rd;
    mt19937 gen(rd());

    // 创建一个均匀分布的随机数分布对象，范围为1到10
    uniform_int_distribution<int> dist(1, 10);

    // 生成随机数
    int randomNum = dist(gen);

    // 输出随机数
    cout << "Random number: " << randomNum << endl;

    return 0;
}

运行上述示例代码，将输出一个在1到10之间的随机数。由于使用了随机数引擎 mt19937，每次运行程序时生成的随机数都可能不同。

所以输出是不确定的。

16、numeric🎰🧿

再次感谢@zhengzhiyun2011的点评虽然是一年前。

这个库其实可以看做cmath的一个副本，我的意思是它也是一些关于数学运算的函数之类，在信奥中有大用处，打过CSP的应该都知道CSP-J2022年初赛的程序理解题用到了这个东西和limit库，好像据说搞倒了一堆人。

好像不全是跟这个有关系。。。

大约有以下几个常用函数：

1、accumulate

这个玩意大家应该都见过，它是用于计算容器中所有元素的总和。也就是‘∑’符号的一种体现。

它接受三个参数：容器的开始迭代器、结束迭代器和初始值。

下面是示例代码，也是是分简便。

#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    int sumn = accumulate(v.begin(), v.end(), 0);
    cout<< sumn ;
    return 0;
}

2、inner_product

这东西没什么好说的 ，认识英语的应该能看出用途，inner_product 函数用于计算两个容器中对应元素乘积的总和。

另：看了看文章，发现实现方法有点意思，简单来说就是矩阵乘法，感兴趣自己上网搜索学习。

示例代码：

#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
    vector<int> v1 = {1, 2, 3};
    vector<int> v2 = {4, 5, 6};
    int ps = inner_product(v1.begin(), v1.end(), v2.begin(), 0);
    cout << ps;
    return 0;
}

3、gcd和lcm

之所以把他俩放一起，是因为他俩不就一个东西嘛。。。

这里还是说一下，gcd是最大公因数，lcm是最小公倍数。

示例代码：

#include <iostream>
#include <numeric>
using namespace std;
int main() {
    int a = 48;
    int b = 18;
    int res = gcd(a, b);
    int res2 = lcm(a,b);
    cout <<res<<" "<<res2;
    return 0;
}

4、min_element 和 max_element 

之所以把他俩放在一起，是因为他俩不就是一个意思吗（在哪见过这句话？）。

就是用于找到容器中的最大值和最小值。

示例代码：

#include <iostream>
#include <numeric>
#include <vector>
#include <algorithm> 
using namespace std;
int main() {
    vector<int> v = {3, 1, 4, 1, 5, 9};
    int min_val = *std::min_element(v.begin(), v.end());
    int max_val = *std::max_element(v.begin(), v.end());
    cout << "Min: " << min_val << endl;
    cout << "Max: " << max_val;

    return 0;
}

 17、limits🐮🍺

也有人写作climits，不过也许差不多。

至于zzy说十分重要，那也确实，在比赛或是编东西的时候总要知道一个问题的一些限制，如数据范围这种东西。而limits库就解决了一些问题，如变量该定多大、函数的使用数据范围等。

宏	描述	值
字符类型
CHAR_BIT	char 类型的位数	通常为 8
CHAR_MIN	char 类型的最小值（有符号或无符号）	-128 或 0
CHAR_MAX	char 类型的最大值（有符号或无符号）	127 或 255
SCHAR_MIN	signed char 类型的最小值	-128
SCHAR_MAX	signed char 类型的最大值	127
UCHAR_MAX	unsigned char 类型的最大值	255
短整数类型
SHRT_MIN	short 类型的最小值	-32768
SHRT_MAX	short 类型的最大值	32767
USHRT_MAX	unsigned short 类型的最大值	65535
整数类型
INT_MIN	int 类型的最小值	-2147483648
INT_MAX	int 类型的最大值	2147483647
UINT_MAX	unsigned int 类型的最大值	4294967295
长整数类型
LONG_MIN	long 类型的最小值	-9223372036854775808L
LONG_MAX	long 类型的最大值	9223372036854775807L
ULONG_MAX	unsigned long 类型的最大值	18446744073709551615UL
长长整数类型
LLONG_MIN	long long 类型的最小值	-9223372036854775808LL
LLONG_MAX	long long 类型的最大值	9223372036854775807LL
ULLONG_MAX	unsigned long long 类型的最大值	18446744073709551615ULL

这就是这个库的东西了。

下面是示例代码（太多了借鉴一下菜鸟教程的。。）：

#include <stdio.h>
#include <limits.h>

int main() {
    printf("Character types:\n");
    printf("CHAR_BIT: %d\n", CHAR_BIT);
    printf("CHAR_MIN: %d\n", CHAR_MIN);
    printf("CHAR_MAX: %d\n", CHAR_MAX);
    printf("SCHAR_MIN: %d\n", SCHAR_MIN);
    printf("SCHAR_MAX: %d\n", SCHAR_MAX);
    printf("UCHAR_MAX: %u\n", UCHAR_MAX);

    printf("\nShort integer types:\n");
    printf("SHRT_MIN: %d\n", SHRT_MIN);
    printf("SHRT_MAX: %d\n", SHRT_MAX);
    printf("USHRT_MAX: %u\n", USHRT_MAX);

    printf("\nInteger types:\n");
    printf("INT_MIN: %d\n", INT_MIN);
    printf("INT_MAX: %d\n", INT_MAX);
    printf("UINT_MAX: %u\n", UINT_MAX);

    printf("\nLong integer types:\n");
    printf("LONG_MIN: %ld\n", LONG_MIN);
    printf("LONG_MAX: %ld\n", LONG_MAX);
    printf("ULONG_MAX: %lu\n", ULONG_MAX);

    printf("\nLong long integer types:\n");
    printf("LLONG_MIN: %lld\n", LLONG_MIN);
    printf("LLONG_MAX: %lld\n", LLONG_MAX);
    printf("ULLONG_MAX: %llu\n", ULLONG_MAX);

    return 0;
}

五、写在后面

以上，完。