C++ 自适应函数符和函数适配器( 二 ) _C++

#include <iostream>#include <functional>int main() {std::negate<int> negate_int;std::negate<double> negate_double;int a = 3;double x = 2.5;std::cout << "negate_int(a) = " << negate_int(a) << std::endl;std::cout << "negate_double(x) = " << negate_double(x) << std::endl;return 0;}输出结果为：
negate_int(a) = -3negate_double(x) = -2.5总之，C++标准库中提供的自适应函数符非常方便，可以根据输入参数类型自动推导出返回值类型，无需手动指定，使得泛型编程更加简单。上述示例代码展示了这些函数符的使用方法，可以根据自己的需要选择合适的函数符来完成相应的运算。
函数适配器函数适配器是 C++ 标准库中的一个重要概念，它可以将一个函数对象适配成另一个函数对象，以满足特定的需求。C++ 标准库中提供了四种函数适配器：std::bind、std::function、std::mem_fn 和 std::reference_wrApper 。

std::bind

std::bind 是一个绑定器，它可以将一个函数对象的参数绑定到指定的值，从而生成一个新的函数对象。std::bind 的语法如下：
template<class F, class... Args>auto bind(F&& f, Args&&... args);其中，F 是需要绑定参数的函数对象，Args 是需要绑定的参数。std::bind 返回一个新的函数对象，它将 F 和 args 绑定在一起。
下面是一个使用 std::bind 的例子：

#include <iostream>#include <functional>int add(int a, int b) {return a + b;}int main() {auto add2 = std::bind(add, 2, std::placeholders::_1);std::cout << add2(3) << std::endl; // 输出 5return 0;}

在这个例子中，我们定义了一个 add 函数，它有两个参数。然后，我们使用 std::bind 将 add 函数的第一个参数绑定为 2，第二个参数使用 std::placeholders::_1 占位符来表示，表示这个参数在调用时将被动态传入。最后，我们通过调用 add2 来计算 2 + 3 的值，得到了结果 5 。

std::function

std::function 是一个函数包装器，它可以将任意可调用对象封装成一个函数对象。std::function 的语法如下：
template<class R, class... Args>class function<R(Args...)>;其中，R 是函数的返回类型，Args 是函数的参数类型列表。std::function 可以封装任意可调用对象，包括函数指针、成员函数指针、lambda 表达式、函数对象等。
下面是一个使用 std::function 的例子：

#include <iostream>#include <functional>int add(int a, int b) {return a + b;}int main() {std::function<int(int, int)> f = add;std::cout << f(2, 3) << std::endl; // 输出 5return 0;}

在这个例子中，我们定义了一个 add 函数，然后使用 std::function 将它封装成一个函数对象 f 。最后，我们通过调用 f 来计算 2 + 3 的值，得到了结果 5 。

std::mem_fn

std::mem_fn 是一个成员函数适配器，它可以将一个成员函数适配成一个函数对象。std::mem_fn 的语法如下：
template<class R, class T>std::mem_fn(R T::* pm);其中，R 是成员函数的返回类型，T 是成员函数所属的类类型，pm 是成员函数指针。
下面是一个使用 std::mem_fn 的例子：

#include <iostream>#include <functional>class A {public:int add(int a, int b) {return a + b;}};int main() {A a;auto f = std::mem_fn(&A::add);std::cout << f(a, 2, 3) << std::endl; // 输出 5return 0;}

在这个例子中，我们定义了一个类 A，它有一个成员函数 add 。然后，我们使用 std::mem_fn 将 add 函数适配成一个函数对象 f 。最后，我们通过调用 f 来计算 a.add(2, 3) 的值，得到了结果 5 。

std::reference_wrapper

std::reference_wrapper 是一个引用包装器，它可以对一个对象进行引用封装，从而生成一个新的函数对象。std::reference_wrapper 的语法如下：
template<class T>class reference_wrapper;其中，T 是要引用封装的对象类型。
下面是一个使用 std::reference_wrapper 的例子：

#include <iostream>#include <functional>int add(int a, int b) {return a + b;}int main() {	int a = 2, b = 3;	auto f = std::ref(add);	std::cout << f(a, b) << std::endl; // 输出 5	return 0;}

自定义函数符和函数适配器在C++中，我们可以自定义函数符和函数适配器来满足特定的需求。下面将分别介绍如何自定义函数符和函数适配器。
首先，自定义函数符需要满足以下条件：