【蓝桥】常用库函数

1、memset()函数

1.1 基本介绍

   

• 界说在头文件<cstring>中
  
• 重要作用是对一块内存地域进行设置值的操作
  

  1.2 函数原型

1. void *memset(void *str, int c, size_t n);

复制代码

• str：指向要填充的内存块的指针
  
• c：要设置的值。该值以int形式传递，但函数在填充之前会将这个值转换为unsigned char
  
• n：要设置的字节数
  
• 返回值：返回指向内存块str的指针
  

1.3 常见用法

1.3.1 初始化数组

   可以用来快速地将数组元素设置为0或其他相同的值
  1.3.2 清空结构体或类对象

   当需要重置结构体或类对象时，可以使用memset()将其所有成员变量设为0
  1.3.3 性能优化

   对于大量数据的初始化，memset()因为其底层实现通常是高度优化的，可能比手动循环赋值更快
  1.4 基础用法

• 初始化一个整数数组
  

1. #include <iostream>
2. #include <cstring> // 必须包含此头文件
4. int main() {
5.     int numbers[5];
6.    
7.     // 使用 memset 将数组每个元素设置为0
8.     // 注意: memset 以字节为单位操作，因此这里每个int(4字节)都被设置为0
9.     memset(numbers, 0, sizeof(numbers));
10.    
11.     // 输出数组内容，验证是否全部被设置为0
12.     for(int i = 0; i < 5; ++i) {
13.         std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
14.     }
15.    
16.     return 0;
17. }

复制代码

2、swap()函数

2.1 基本介绍

   

• 界说在头文件<utility>中
  
• 重要作用是用于互换两个变量值
  

  2.2 函数原型

1. void std::swap(T& a, T& b);

复制代码

• a：要互换值的第一个变量的引用
  
• b：要互换值的第二个变量的引用
  

2.3 常见用法

2.3.1 互换两个变量的值

   最基本的应用场景
  2.3.2 互换容器内容

   对于STL容器，除了使用通用的swap函数外，还可以调用容器自身的swap方法，这通常是更高效的选择
  2.3.3 自界说范例

   如果需要对自界说范例进行互换操作，可以通过重载swap函数来提高服从大概实现特定逻辑
  2.4 基础用法

2.4.1 基本范例互换

1. #include <iostream>
2. #include <utility> // 包含std::swap
4. int main() {
5.     int a = 5, b = 10;
6.     std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;
8.     std::swap(a, b); // 使用std::swap交换a和b的值
10.     std::cout << "After swap: a = " << a << ", b = " << b << std::endl;
11.     return 0;
12. }

复制代码

2.4.2 STL容器互换

1. #include <iostream>
2. #include <vector>
3. #include <utility> // 包含std::swap
5. int main() {
6.     std::vector<int> vec1 = {1, 2, 3};
7.     std::vector<int> vec2 = {4, 5, 6};
9.     std::cout << "Before swap:" << std::endl;
10.     std::cout << "vec1 contains:";
11.     for(auto& i : vec1) std::cout << ' ' << i;
12.     std::cout << "\nvec2 contains:";
13.     for(auto& i : vec2) std::cout << ' ' << i;
14.     std::cout << std::endl;
16.     // 交换vec1和vec2的内容
17.     vec1.swap(vec2); // 或者使用std::swap(vec1, vec2);
19.     std::cout << "After swap:" << std::endl;
20.     std::cout << "vec1 contains:";
21.     for(auto& i : vec1) std::cout << ' ' << i;
22.     std::cout << "\nvec2 contains:";
23.     for(auto& i : vec2) std::cout << ' ' << i;
24.     std::cout << std::endl;
26.     return 0;
27. }

复制代码

3、reverse()函数

3.1 基本介绍

   

• 界说在头文件<algorithm>中
  
• 重要作用是用于反转序列容器（如vector，string，deque，array等）中的元素次序
  

  3.2 函数原型

1. void reverse(Iterator first, Iterator last);

复制代码

• first：要反转范围的初始位置
  
• last：要反转范围的结束位置（但不包括last所指向的元素）。换句话说，它是半开区间[first, last)中最后一个元素的下一个位置
  

3.3 常见用法

3.3.1 反转数组或向量

   可以用来快速地将一个数组或向量中的元素次序颠倒
  3.3.2 字符串处理

   对于std::string范例的数据，reverse()可以用来反转字符串内容
  3.3.3 自界说容器

   如果自界说的容器支持双向迭代器，也可以使用reverse()来反转其中的元素
  3.4 基础用法

3.4.1 反转std::vector<int>

1. #include <iostream>
2. #include <vector>
3. #include <algorithm> // 包含reverse函数
5. int main() {
6.     std::vector<int> vec = {1, 2, 3, 4, 5};
8.     std::cout << "Original vector: ";
9.     for(int i : vec) {
10.         std::cout << i << ' ';
11.     }
12.     std::cout << std::endl;
14.     std::reverse(vec.begin(), vec.end()); // 使用reverse函数反转vector
16.     std::cout << "Reversed vector: ";
17.     for(int i : vec) {
18.         std::cout << i << ' ';
19.     }
20.     std::cout << std::endl;
22.     return 0;
23. }

复制代码

3.4.2 反转std::string

1. #include <iostream>
2. #include <string>
3. #include <algorithm> // 包含reverse函数
5. int main() {
6.     std::string str = "hello world";
8.     std::cout << "Original string: " << str << std::endl;
10.     std::reverse(str.begin(), str.end()); // 使用reverse函数反转字符串
12.     std::cout << "Reversed string: " << str << std::endl;
14.     return 0;
15. }

复制代码

4、unique()函数

4.1 基本介绍

   

• 界说在头文件<algorithm>中
  
• 重要作用是用于移除给定范围内的连续重复元素，只保留每个重复序列的第一个实例
  
• 时间复杂度为O(n)
  

  4.2 函数原型

1. ForwardIt unique(ForwardIt first, ForwardIt last);
2. ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPredicate p);

复制代码

• first，last：界说了要处理的元素范围。这个范围是半开区间[first, last)，意味着包含 first指向的元素，但不包括last指向的元素
  
• BinaryPredicate p：可选参数，用于自界说比力规则，默认使用operator==
  

4.3 常见用法

4.3.1 移除连续重复项

   这是最直接的应用场景，实用于任何支持双向迭代器的容器（如vector，deque等）
  4.3.2 团结erase使用

   为了实际删除容器中多余的元素，通常会将unique的返回值与erase方法团结使用
  4.3.3 自界说比力逻辑

   通过提供第三个参数，可以指定差异的比力方式来决定哪些元素被认为是重复的
  4.4 基础用法

4.4.1 移除std::vector<int>中的连续重复项

1. #include <iostream>
2. #include <vector>
3. #include <algorithm> // 包含unique和sort函数
5. int main() {
6.     std::vector<int> vec = {1, 2, 2, 3, 2, 4, 4, 5};
8.     // 首先对vector进行排序，因为unique只能移除相邻的重复项
9.     std::sort(vec.begin(), vec.end());
11.     // 使用unique移除连续重复项
12.     auto last = std::unique(vec.begin(), vec.end());
14.     // 删除多余的元素
15.     vec.erase(last, vec.end());
17.     // 输出结果
18.     for(int i : vec) {
19.         std::cout << i << " ";
20.     }
21.     std::cout << std::endl;
23.     return 0;
24. }

复制代码

4.4.2 使用自界说比力函数

1. #include <iostream>
2. #include <vector>
3. #include <algorithm>
5. bool customCompare(int a, int b) {
6.     return (a % 3) == (b % 3); // 自定义比较规则，这里按模3的结果分组
7. }
9. int main() {
10.     std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8, 9};
12.     // 使用unique配合自定义比较函数
13.     auto last = std::unique(vec.begin(), vec.end(), customCompare);
15.     // 删除多余的元素
16.     vec.erase(last, vec.end());
18.     // 输出结果
19.     for(int i : vec) {
20.         std::cout << i << " ";
21.     }
22.     std::cout << std::endl;
24.     return 0;
25. }

复制代码

---

微语录：不积跬步，无以至千里；不积小流，无以成江海。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。