std::for_each?是C++标准库中的一个算法，用于对指定范围内的元素执行指定的操作。它通常用于迭代容器中的元素，对每个元素执行某种操作。下面是一个简单的例子，说明如何使用?std::for_each：
#include <iostream>
#include <vector>
#include <algorithm>
// 一个简单的函数，用于打印元素
void printElement(int element) {
std::cout << element << " ";
}
int main() {
// 创建一个包含一些整数的 vector
std::vector<int> myVector = {1, 2, 3, 4, 5};
// 使用 std::for_each 打印每个元素
std::cout << "Elements in the vector: ";
std::for_each(myVector.begin(), myVector.end(), printElement);
std::cout << std::endl;
return 0;
}在这个例子中，我们定义了一个函数?printElement，它接受一个整数参数并将其打印到标准输出。然后，我们创建一个包含一些整数的 vector (myVector)，并使用?std::for_each?算法遍历该 vector，对每个元素调用?printElement?函数，从而实现对每个元素的打印操作。
需要注意的是，std::for_each?还可以使用 lambda 表达式，这样可以更紧凑地表示操作。下面是使用 lambda 表达式的修改版本：
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
// 创建一个包含一些整数的 vector
std::vector<int> myVector = {1, 2, 3, 4, 5};
// 使用 std::for_each 和 lambda 表达式打印每个元素
std::cout << "Elements in the vector: ";
std::for_each(myVector.begin(), myVector.end(), [](int element) {
std::cout << element << " ";
});
std::cout << std::endl;
return 0;
}在这个版本中，我们使用了 lambda 表达式?[](int element) { std::cout << element << " "; }?作为?std::for_each?的第三个参数，实现了与之前相同的打印操作。Lambda 表达式的使用使得代码更为紧凑。
std::for_each?函数是一个算法，其参数列表中只接受一个可调用对象（函数或函数对象），并且该可调用对象必须接受一个参数，通常是容器中元素的类型。因此，std::for_each?直接支持传递额外参数的能力有限。
然而，你可以使用 lambda 表达式或?std::bind?来传递额外的参数。以下是两种方式的示例：
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> myVector = {1, 2, 3, 4, 5};
// 额外参数
int extraParameter = 10;
// 使用 lambda 表达式传递额外参数
std::for_each(myVector.begin(), myVector.end(), [extraParameter](int element) {
std::cout << element + extraParameter << " ";
});
std::cout << std::endl;
return 0;
}#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
void printWithExtra(int element, int extraParameter) {
std::cout << element + extraParameter << " ";
}
int main() {
std::vector<int> myVector = {1, 2, 3, 4, 5};
// 额外参数
int extraParameter = 10;
// 使用 std::bind 传递额外参数
std::for_each(myVector.begin(), myVector.end(), std::bind(printWithExtra, std::placeholders::_1, extraParameter));
std::cout << std::endl;
return 0;
}在这两个示例中，我们都引入了一个额外的参数?extraParameter。使用 lambda 表达式时，我们直接在 lambda 的捕获列表中引入了额外的参数。使用?std::bind?时，我们使用了?std::placeholders::_1?来表示?for_each?提供的元素参数。这两种方式都可以用于传递额外的参数给?std::for_each?处理的函数。
std::for_each?支持使用函数对象（function object）作为其第三个参数。函数对象是具有函数调用操作符（operator()）的类或结构体，可以像函数一样调用。
下面是一个使用函数对象的示例：
#include <iostream>
#include <vector>
#include <algorithm>
// 定义一个函数对象
struct PrintWithExtra {
int extraParameter;
// 构造函数，用于初始化额外参数
PrintWithExtra(int extra) : extraParameter(extra) {}
// 重载函数调用操作符
void operator()(int element) const {
std::cout << element + extraParameter << " ";
}
};
int main() {
std::vector<int> myVector = {1, 2, 3, 4, 5};
// 创建函数对象实例，并初始化额外参数
PrintWithExtra printObject(10);
// 使用函数对象传递额外参数
std::for_each(myVector.begin(), myVector.end(), printObject);
std::cout << std::endl;
return 0;
}在这个例子中，我们定义了一个名为?PrintWithExtra?的函数对象结构体，该结构体包含一个额外参数?extraParameter，并重载了函数调用操作符。然后，我们创建了一个函数对象实例?printObject，并将其传递给?std::for_each。
函数对象提供了一种将状态（如额外参数）传递给算法的方式，因此你可以在处理每个元素时使用这些状态。函数对象可以是普通函数指针、函数对象类的实例，或者是使用 lambda 表达式创建的匿名函数对象。
std::for_each?不直接支持函数模板作为其第三个参数。它的第三个参数期望的是一个可调用对象，而函数模板并不是可调用对象。
然而，你可以使用函数模板的实例、lambda 表达式、函数对象等作为?std::for_each?的第三个参数。这样可以实现对不同类型的元素执行相同的操作，只要该操作可以通过可调用对象表示。
以下是一个使用函数模板的示例：
#include <iostream>
#include <vector>
#include <algorithm>
// 定义一个函数模板
template <typename T>
void printElement(const T& element) {
std::cout << element << " ";
}
int main() {
std::vector<int> intVector = {1, 2, 3, 4, 5};
std::vector<double> doubleVector = {1.1, 2.2, 3.3, 4.4, 5.5};
// 使用函数模板传递给 std::for_each
std::for_each(intVector.begin(), intVector.end(), printElement<int>);
std::cout << std::endl;
std::for_each(doubleVector.begin(), doubleVector.end(), printElement<double>);
std::cout << std::endl;
return 0;
}在这个例子中，我们定义了一个函数模板?printElement，它接受一个参数并将其打印。然后，我们使用函数模板实例化的形式?printElement<int>?和?printElement<double>?分别作为?std::for_each?的第三个参数，以对不同类型的 vector 执行相同的操作。
如果你想在使用函数模板或其他可调用对象时传递额外的参数，可以使用 lambda 表达式或?std::bind?来实现。以下是两种方式的示例：
#include <iostream>
#include <vector>
#include <algorithm>
// 定义一个函数模板
template <typename T>
void printElementWithExtra(const T& element, int extraParameter) {
std::cout << element + extraParameter << " ";
}
int main() {
std::vector<int> intVector = {1, 2, 3, 4, 5};
std::vector<double> doubleVector = {1.1, 2.2, 3.3, 4.4, 5.5};
// 使用 lambda 表达式传递额外参数
int extraParameter = 10;
std::for_each(intVector.begin(), intVector.end(), [extraParameter](int element) {
printElementWithExtra(element, extraParameter);
});
std::cout << std::endl;
std::for_each(doubleVector.begin(), doubleVector.end(), [extraParameter](double element) {
printElementWithExtra(element, extraParameter);
});
std::cout << std::endl;
return 0;
}#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
// 定义一个函数模板
template <typename T>
void printElementWithExtra(const T& element, int extraParameter) {
std::cout << element + extraParameter << " ";
}
int main() {
std::vector<int> intVector = {1, 2, 3, 4, 5};
std::vector<double> doubleVector = {1.1, 2.2, 3.3, 4.4, 5.5};
// 使用 std::bind 传递额外参数
int extraParameter = 10;
std::for_each(intVector.begin(), intVector.end(), std::bind(printElementWithExtra<int>, std::placeholders::_1, extraParameter));
std::cout << std::endl;
std::for_each(doubleVector.begin(), doubleVector.end(), std::bind(printElementWithExtra<double>, std::placeholders::_1, extraParameter));
std::cout << std::endl;
return 0;
}这两个示例中，我们通过 lambda 表达式和?std::bind?分别传递了额外的参数给?printElementWithExtra?函数模板。在 lambda 表达式中，我们使用捕获列表?[extraParameter]?来捕获额外参数。在?std::bind?中，我们使用?std::placeholders::_1?来表示?for_each?提供的元素参数。
std::for_each?不直接支持类模板（class template）作为其第三个参数。std::for_each?的第三个参数需要是一个可调用对象，而类模板不是可调用对象。
然而，你可以使用类模板的实例、lambda 表达式、函数对象等作为?std::for_each?的第三个参数。这样可以实现对不同类型的元素执行相同的操作，只要该操作可以通过可调用对象表示。
以下是一个使用类模板实例的示例：
#include <iostream>
#include <vector>
#include <algorithm>
// 定义一个类模板
template <typename T>
struct PrintElement {
void operator()(const T& element) const {
std::cout << element << " ";
}
};
int main() {
std::vector<int> intVector = {1, 2, 3, 4, 5};
std::vector<double> doubleVector = {1.1, 2.2, 3.3, 4.4, 5.5};
// 使用类模板实例作为 std::for_each 的第三个参数
PrintElement<int> printInt;
PrintElement<double> printDouble;
std::for_each(intVector.begin(), intVector.end(), printInt);
std::cout << std::endl;
std::for_each(doubleVector.begin(), doubleVector.end(), printDouble);
std::cout << std::endl;
return 0;
}在这个例子中，我们定义了一个名为?PrintElement?的类模板，该类模板重载了函数调用操作符。然后，我们使用类模板实例的形式?PrintElement<int>?和?PrintElement<double>?分别作为?std::for_each?的第三个参数，以对不同类型的 vector 执行相同的操作。