🎩 欢迎来到技术探索的奇幻世界👨💻
📜 个人主页：@一伦明悦-CSDN博客
✍🏻 作者简介： C++软件开发、Python机器学习爱好者
🗣️ 互动与支持：💬评论 👍🏻点赞 📂收藏 👀关注+
如果文章有所帮助，欢迎留下您宝贵的评论，
点赞加收藏支持我，点击关注，一起进步！
前言
STL（Standard Template Library）是C++标准库的一部分，提供了丰富的数据结构和算法，用于处理数据和实现常见的计算任务。STL中的算法分为几类，包括遍历算法、修改算法、排序算法、查找算法、数值算法等，每类算法都有其特定的应用场景和功能。
正文
01-拷贝和替换算法之copy用法
在 C++ 的 STL（Standard Template Library）中，提供了一系列的算法来操作容器和序列。其中，拷贝和替换算法是常见的操作之一，它们能够方便地在容器或序列之间进行数据的复制或替换。本文将重点介绍
std::copy算法的用法和示例。1.
std::copy简介
std::copy算法用于将一个序列的元素复制到另一个序列中。它的原型定义在<algorithm>头文件中，并且通常与迭代器一起使用，允许在不同容器类型之间或同一容器内不同位置之间进行数据的复制操作。2.
std::copy函数签名template< class InputIt, class OutputIt > OutputIt copy( InputIt first, InputIt last, OutputIt d_first );
first,last：定义了输入序列的起始和结束位置（包括起始，但不包括结束）。d_first：定义了输出序列的起始位置，即从这里开始复制数据。3. 参数说明
InputIt：表示输入序列的迭代器类型，通常是指向要复制的容器的迭代器。OutputIt：表示输出序列的迭代器类型，通常是指向目标容器或输出位置的迭代器。4. 使用示例
下面通过一个简单的示例来说明
std::copy的具体用法。#include <iostream> #include <algorithm> #include <vector>int main() {std::vector<int> source = {1, 2, 3, 4, 5};std::vector<int> destination(5); // 目标容器，预先分配空间// 使用 std::copy 将 source 中的元素复制到 destination 中std::copy(source.begin(), source.end(), destination.begin());// 输出目标容器中的元素，验证复制结果for (int num : destination) {std::cout << num << " ";}std::cout << std::endl;return 0; }5. 示例解释
- 首先，我们定义了一个
source容器，其中包含了整数{1, 2, 3, 4, 5}。- 然后，我们创建了
destination容器，它的大小与source相同，并预先分配了足够的空间来存放复制后的数据。- 在
std::copy调用中，我们传递了source.begin()和source.end()作为输入范围，并且传递了destination.begin()作为输出起始位置。这样，source中的所有元素被复制到了destination中。- 最后，通过简单的循环输出，我们验证了
destination中的元素确实与source中的元素相同。6. 总结
使用
std::copy算法能够方便地完成容器间的数据复制操作，它的灵活性和效率使得在实际编程中被广泛应用。理解其参数和用法能够帮助程序员更高效地处理数据复制任务，同时提升代码的可读性和维护性。
这段代码演示了如何使用 C++ STL 中的 <algorithm> 头文件中的 copy 函数和 for_each 算法，以及自定义函数对象来实现向量之间的元素复制和打印输出。
1. 包含头文件
#include <algorithm>
#include <vector>
#include <iostream>
这些是 C++ 标准库的头文件，分别包含了 copy 算法、vector 容器和输入输出流。
2. 自定义函数对象 myPrint
class myPrint
{
public:void operator()(int val){std::cout << val << " ";}
};
myPrint 是一个函数对象类，重载了 operator()，用于输出传入的整数 val。在 for_each 算法中，会使用这个函数对象来打印容器中的元素。
3. test01 函数
void test01()
{std::vector<int> v1;for (int i = 0; i < 10; i++) {v1.push_back(i + 1);}std::vector<int> v2;v2.resize(v1.size());// 使用 std::copy 将 v1 中的元素复制到 v2 中std::copy(v1.begin(), v1.end(), v2.begin());// 使用 for_each 和自定义函数对象 myPrint 输出 v2 中的元素std::for_each(v2.begin(), v2.end(), myPrint());std::cout << std::endl;
}
详细解释：
-
创建两个向量
v1和v2：v1用于存储整数 1 到 10。v2先调整大小为v1的大小，以准备接收从v1复制的元素。
-
使用
std::copy复制元素：std::copy(v1.begin(), v1.end(), v2.begin())将v1中的元素复制到v2中。v1.begin()和v1.end()分别是v1的起始和结束迭代器，v2.begin()是v2的起始迭代器。
-
使用
for_each打印元素：std::for_each(v2.begin(), v2.end(), myPrint())对v2中的每个元素都调用myPrint函数对象的operator()，从而将元素依次输出到标准输出流中。
4. main 函数
int main() {test01();system("pause");return 0;
}
main 函数调用 test01() 来执行示例代码，并在程序结束前调用 system("pause") 来暂停控制台，以便查看输出结果。
总结
这段代码展示了如何使用 std::copy 将一个向量 (v1) 的内容复制到另一个向量 (v2) 中，并使用 for_each 结合自定义函数对象来遍历 v2 并输出其内容。这种方式利用了 STL 提供的算法和函数对象的灵活性，使代码更加清晰和易于维护。
#include <algorithm>
#include <vector>
class myPrint
{
public:void operator()(int val){cout << val << " ";}
};
void test01()
{vector<int> v1;for (int i = 0; i < 10; i++) {v1.push_back(i + 1);}vector<int> v2;v2.resize(v1.size());copy(v1.begin(), v1.end(), v2.begin());for_each(v2.begin(), v2.end(), myPrint());cout << endl;
}
int main() {test01();system("pause");return 0;
}
02-拷贝和替换算法之replace用法
在 C++ 的 STL（Standard Template Library）中，除了拷贝（如
std::copy）之外，还提供了替换算法，其中std::replace是其中之一。这篇文章将详细介绍std::replace算法的用法和示例。1.
std::replace简介
std::replace算法用于在容器中将指定值的所有元素替换为另一个值。它的原型定义在<algorithm>头文件中，可以轻松地对容器中的元素进行替换操作。2.
std::replace函数签名template< class ForwardIt, class T > void replace( ForwardIt first, ForwardIt last, const T& old_value, const T& new_value );
first,last：定义了要替换的元素范围，从first（包含）到last（不包含）。old_value：要被替换的值。new_value：替换成的新值。3. 参数说明
ForwardIt：表示前向迭代器类型，通常是指向容器的迭代器。T：表示元素的类型，通常是容器中存储的元素类型。4. 使用示例
下面通过一个简单的示例来说明
std::replace的具体用法。#include <iostream> #include <algorithm> #include <vector>int main() {std::vector<int> v = {1, 2, 3, 4, 2, 5, 2};// 使用 std::replace 将 v 中的所有值为 2 的元素替换为 20std::replace(v.begin(), v.end(), 2, 20);// 输出替换后的向量内容for (int num : v) {std::cout << num << " ";}std::cout << std::endl;return 0; }5. 示例解释
- 首先，我们定义了一个
vector容器v，其中包含了整数{1, 2, 3, 4, 2, 5, 2}。- 然后，我们使用
std::replace调用std::replace(v.begin(), v.end(), 2, 20)，将v中所有值为 2 的元素替换为 20。- 最后，通过简单的循环输出，我们验证了替换操作的结果，输出为
1 20 3 4 20 5 20。6. 总结
使用
std::replace算法能够快速地替换容器中的特定值，提高了代码的可读性和简洁性。理解其参数和用法可以帮助程序员在实际编程中处理替换操作，尤其是在需要大量元素替换时尤为方便。
这段代码展示了如何使用 C++ STL 中的 replace 算法来替换容器中指定值的元素，并结合自定义函数对象 myPrint 打印容器中的元素。
1. 包含头文件
#include <algorithm>
#include <vector>
#include <iostream>
这些是 C++ 标准库的头文件，分别包含了 replace 算法、vector 容器和输入输出流。
2. 自定义函数对象 myPrint
class myPrint
{
public:void operator()(int val){std::cout << val << " ";}
};
myPrint 是一个函数对象类，重载了 operator()，用于输出传入的整数 val。在 for_each 算法中，会使用这个函数对象来打印容器中的元素。
3. test01 函数
void test01()
{std::vector<int> v;v.push_back(20);v.push_back(30);v.push_back(20);v.push_back(40);v.push_back(50);v.push_back(10);v.push_back(20);std::cout << "替换前：" << std::endl;std::for_each(v.begin(), v.end(), myPrint());std::cout << std::endl;// 将容器中的20 替换成 2000std::cout << "替换后：" << std::endl;std::replace(v.begin(), v.end(), 20, 2000);std::for_each(v.begin(), v.end(), myPrint());std::cout << std::endl;
}
详细解释：
-
创建向量
v：v用于存储整数元素{20, 30, 20, 40, 50, 10, 20}。
-
打印原始容器元素：
std::for_each(v.begin(), v.end(), myPrint())使用自定义函数对象myPrint打印容器中的元素，即输出 “20 30 20 40 50 10 20”。
-
使用
std::replace进行替换：std::replace(v.begin(), v.end(), 20, 2000)将容器中所有值为 20 的元素替换为 2000。
-
打印替换后的容器元素：
- 再次使用
std::for_each(v.begin(), v.end(), myPrint())打印容器中的元素，此时输出为 “2000 30 2000 40 50 10 2000”，验证了替换操作的结果。
- 再次使用
4. main 函数
int main() {test01();system("pause");return 0;
}
main 函数调用 test01() 来执行示例代码，并在程序结束前调用 system("pause") 来暂停控制台，以便查看输出结果。
总结
这段代码演示了如何使用 std::replace 算法将容器中指定值的元素替换为另一个值，并通过自定义函数对象结合 for_each 算法打印容器中的元素。这种方式利用了 STL 提供的算法和函数对象的灵活性，使得替换操作变得简洁而直观。
#include <algorithm>
#include <vector>
class myPrint
{
public:void operator()(int val){cout << val << " ";}
};
void test01()
{vector<int> v;v.push_back(20);v.push_back(30);v.push_back(20);v.push_back(40);v.push_back(50);v.push_back(10);v.push_back(20);cout << "替换前：" << endl;for_each(v.begin(), v.end(), myPrint());cout << endl;//将容器中的20 替换成 2000cout << "替换后：" << endl;replace(v.begin(), v.end(), 20, 2000);for_each(v.begin(), v.end(), myPrint());cout << endl;
}
int main() {test01();system("pause");return 0;
}03-拷贝和替换算法之replace_if用法
在 C++ 的 STL（Standard Template Library）中，除了拷贝（如
std::copy）和替换（如std::replace）之外，还提供了条件替换算法std::replace_if。这篇文章将详细介绍std::replace_if算法的用法和示例。1.
std::replace_if简介
std::replace_if算法用于在容器中根据指定的条件替换元素。它的原型定义在<algorithm>头文件中，可以根据自定义的条件函数对容器中的元素进行替换操作。2.
std::replace_if函数签名template< class ForwardIt, class UnaryPredicate, class T > void replace_if( ForwardIt first, ForwardIt last, UnaryPredicate p, const T& new_value );
first,last：定义了要替换的元素范围，从first（包含）到last（不包含）。p：用于判断要替换的元素的一元谓词（Unary Predicate）。new_value：替换成的新值。3. 参数说明
ForwardIt：表示前向迭代器类型，通常是指向容器的迭代器。UnaryPredicate：表示一元谓词，接受一个参数并返回bool值的函数对象，用于判断要替换的元素是否符合条件。T：表示元素的类型，通常是容器中存储的元素类型。4. 使用示例
下面通过一个简单的示例来说明
std::replace_if的具体用法。#include <iostream> #include <algorithm> #include <vector>bool isEven(int num) {return num % 2 == 0; }int main() {std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};// 使用 std::replace_if 将 v 中所有偶数替换为 0std::replace_if(v.begin(), v.end(), isEven, 0);// 输出替换后的向量内容for (int num : v) {std::cout << num << " ";}std::cout << std::endl;return 0; }5. 示例解释
- 首先，我们定义了一个
vector容器v，其中包含了整数{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}。- 然后，我们使用
std::replace_if调用std::replace_if(v.begin(), v.end(), isEven, 0)，将v中所有偶数替换为 0，其中isEven是一个用于判断是否为偶数的一元谓词。- 最后，通过简单的循环输出，我们验证了替换操作的结果，输出为
1 0 3 0 5 0 7 0 9 0。6. 总结
使用
std::replace_if算法能够根据自定义条件函数对容器中的元素进行替换，进一步提高了算法的灵活性和可扩展性。理解其参数和用法可以帮助程序员在实际编程中处理更加复杂的替换操作，例如基于特定条件替换元素。
这段代码演示了如何使用 std::replace_if 算法来替换容器中符合特定条件的元素。下面我们逐步解释每个部分的功能和作用。
包含头文件和定义类
首先是头文件的包含和两个类的定义：
#include <algorithm>
#include <vector>
#include <iostream>class myPrint
{
public:void operator()(int val){std::cout << val << " ";}
};class ReplaceGreater30
{
public:bool operator()(int val){return val >= 30;}
};
-
头文件包含：
- 包含了必要的头文件
<algorithm>、<vector>和<iostream>。
- 包含了必要的头文件
-
自定义类
myPrint：- 这是一个函数对象类，重载了
operator()，用于打印传入的整数val。
- 这是一个函数对象类，重载了
-
自定义类
ReplaceGreater30：- 这是一个谓词类（Predicate），重载了
operator()，根据传入的整数val判断是否大于等于 30，并返回相应的布尔值。
- 这是一个谓词类（Predicate），重载了
函数 test01()
接下来是 test01() 函数的实现：
void test01()
{std::vector<int> v;v.push_back(20);v.push_back(30);v.push_back(20);v.push_back(40);v.push_back(50);v.push_back(10);v.push_back(20);std::cout << "替换前：" << std::endl;std::for_each(v.begin(), v.end(), myPrint());std::cout << std::endl;// 将容器中大于等于的30 替换成 3000std::cout << "替换后：" << std::endl;std::replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);std::for_each(v.begin(), v.end(), myPrint());std::cout << std::endl;
}
详细解释：
-
创建向量
v：v用于存储整数元素{20, 30, 20, 40, 50, 10, 20}。
-
打印原始容器元素：
- 使用
std::for_each(v.begin(), v.end(), myPrint())打印容器中的元素，输出 “20 30 20 40 50 10 20”。
- 使用
-
使用
std::replace_if进行替换：std::replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000)将容器中所有满足ReplaceGreater30()条件（即大于等于 30）的元素替换为 3000。
-
打印替换后的容器元素：
- 再次使用
std::for_each(v.begin(), v.end(), myPrint())打印容器中的元素，输出为 “20 3000 20 3000 3000 10 20”，验证了替换操作的结果。
- 再次使用
main 函数
最后是 main() 函数，用于调用 test01() 函数并暂停程序执行：
int main() {test01();system("pause");return 0;
}
总结
这段代码展示了如何利用 std::replace_if 算法根据自定义的条件谓词类 ReplaceGreater30，将容器中符合条件的元素替换为指定的值。这种方式能够灵活地处理复杂的替换逻辑，通过结合函数对象和算法，提升了代码的可读性和可维护性。
#include <algorithm>
#include <vector>
class myPrint
{
public:void operator()(int val){cout << val << " ";}
};
class ReplaceGreater30
{
public:bool operator()(int val){return val >= 30;}
};
void test01()
{vector<int> v;v.push_back(20);v.push_back(30);v.push_back(20);v.push_back(40);v.push_back(50);v.push_back(10);v.push_back(20);cout << "替换前：" << endl;for_each(v.begin(), v.end(), myPrint());cout << endl;//将容器中大于等于的30 替换成 3000cout << "替换后：" << endl;replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);for_each(v.begin(), v.end(), myPrint());cout << endl;
}
int main() {test01();system("pause");return 0;
}
04-拷贝和替换算法之swap用法
在 C++ 的 STL（Standard Template Library）中，除了拷贝（如
std::copy）和替换（如std::replace和std::replace_if）之外，还有一个重要的算法std::swap，用于交换两个元素的值。下面将详细介绍std::swap算法的用法和示例。1.
std::swap简介
std::swap算法用于交换两个元素的值。它的原型定义在<algorithm>头文件中，可以用于交换容器中的元素值。2.
std::swap函数签名template< class T > void swap( T& a, T& b );
a,b：要交换值的两个对象。3. 参数说明
T：表示元素的类型。4. 使用示例
下面通过一个简单的示例来说明
std::swap的具体用法。#include <iostream> #include <algorithm> #include <vector>int main() {std::vector<int> v = {1, 2, 3, 4, 5};// 交换第一个和最后一个元素的值std::swap(v[0], v[v.size() - 1]);// 输出交换后的向量内容for (int num : v) {std::cout << num << " ";}std::cout << std::endl;return 0; }5. 示例解释
- 首先，我们定义了一个
vector容器v，其中包含了整数{1, 2, 3, 4, 5}。- 然后，我们使用
std::swap将第一个元素和最后一个元素的值进行了交换，即将v[0]和v[4]的值交换。- 最后，通过简单的循环输出，我们验证了交换操作的结果，输出为
5 2 3 4 1。6. 总结
使用
std::swap算法能够快速方便地交换两个元素的值，是 C++ 中常用的一个算法之一。它在容器操作中尤其有用，能够简化代码并提高效率。
这段代码演示了如何使用 std::swap 算法来交换两个容器的内容。下面逐步解释每个部分的功能和作用。
包含头文件和定义类
首先是头文件的包含和一个自定义的函数对象类：
#include <algorithm>
#include <vector>
#include <iostream>class myPrint
{
public:void operator()(int val){std::cout << val << " ";}
};
-
头文件包含：
- 包含了必要的头文件
<algorithm>、<vector>和<iostream>。
- 包含了必要的头文件
-
自定义类
myPrint：- 这是一个函数对象类，重载了
operator()，用于打印传入的整数val。
- 这是一个函数对象类，重载了
函数 test01()
接下来是 test01() 函数的实现：
void test01()
{std::vector<int> v1;std::vector<int> v2;for (int i = 0; i < 10; i++) {v1.push_back(i);v2.push_back(i + 100);}std::cout << "交换前： " << std::endl;std::for_each(v1.begin(), v1.end(), myPrint());std::cout << std::endl;std::for_each(v2.begin(), v2.end(), myPrint());std::cout << std::endl;std::cout << "交换后： " << std::endl;std::swap(v1, v2);std::for_each(v1.begin(), v1.end(), myPrint());std::cout << std::endl;std::for_each(v2.begin(), v2.end(), myPrint());std::cout << std::endl;
}
详细解释：
-
创建两个向量
v1和v2：v1包含了整数{0, 1, 2, ..., 9}。v2包含了整数{100, 101, 102, ..., 109}，即每个元素比v1中对应位置的元素大 100。
-
打印交换前的两个容器元素：
- 分别使用
std::for_each打印v1和v2的元素，验证初始化结果。
- 分别使用
-
使用
std::swap进行容器交换：std::swap(v1, v2)将v1和v2的内容进行交换。
-
打印交换后的两个容器元素：
- 再次使用
std::for_each打印交换后的v1和v2的元素，验证交换操作的正确性。
- 再次使用
main 函数
最后是 main() 函数，用于调用 test01() 函数并暂停程序执行：
int main() {test01();system("pause");return 0;
}
总结
这段代码展示了如何使用 std::swap 算法来交换两个容器的内容。通过 std::swap(v1, v2)，可以快速高效地交换两个容器，而不需要手动遍历和交换每个元素，提高了代码的简洁性和可读性。
#include <algorithm>
#include <vector>
class myPrint
{
public:void operator()(int val){cout << val << " ";}
};
void test01()
{vector<int> v1;vector<int> v2;for (int i = 0; i < 10; i++) {v1.push_back(i);v2.push_back(i + 100);}cout << "交换前： " << endl;for_each(v1.begin(), v1.end(), myPrint());cout << endl;for_each(v2.begin(), v2.end(), myPrint());cout << endl;cout << "交换后： " << endl;swap(v1, v2);for_each(v1.begin(), v1.end(), myPrint());cout << endl;for_each(v2.begin(), v2.end(), myPrint());cout << endl;
}
int main() {test01();system("pause");return 0;
}总结
STL（Standard Template Library）是C++标准库的一部分，提供了丰富的数据结构和算法，用于处理数据和实现常见的计算任务。STL中的算法分为几类，包括遍历算法、修改算法、排序算法、查找算法、数值算法等，每类算法都有其特定的应用场景和功能。
