C++自适应函数符和函数适配器

https://m.toutiao.com/is/DJ9U4pa/?= 

C++自适应函数符和函数适配器是C++标准库中非常重要的概念，它们为C++程序员提供了更加灵活和高效的编程方式。自适应函数符是指一类函数对象，可以根据输入的参数类型自动推导出返回值类型，无需手动指定。C++标准库中提供了多种自适应函数符，包括加法、减法、乘法、除法、取模运算、取反等函数符。函数适配器是指将一个函数对象适配成另一个函数对象，以满足特定的需求。C++标准库中提供了多种函数适配器，包括绑定器、函数包装器、成员函数适配器和引用包装器等。

自适应函数符

C++标准库中的自适应函数符是一种函数对象，它可以根据输入的参数类型自动推导出返回值类型。这些函数符通常用于泛型编程中，可以适用于不同的数据类型。C++标准库中提供了多种自适应函数符，包括加法、减法、乘法、除法、取模运算和取反等函数符。

1. std::plus：加法函数符

std::plus是一个二元函数对象，用于实现加法运算。当输入为两个整数时，返回的结果也是整数类型；当输入为两个浮点数时，返回的结果也是浮点数类型。示例代码如下：

#include <iostream>#include <functional>int main() { std::plus<int> add_int; std::plus<double> add_double; int a = 1, b = 2; double x = 1.5, y = 2.5; std::cout << 'add_int(a, b) = ' << add_int(a, b) << std::endl; std::cout << 'add_double(x, y) = ' << add_double(x, y) << std::endl; return 0;}

输出结果为：

add_int(a, b) = 3add_double(x, y) = 4

1. std::minus：减法函数符

std::minus也是一个二元函数对象，用于实现减法运算。当输入为两个整数时，返回的结果也是整数类型；当输入为两个浮点数时，返回的结果也是浮点数类型。示例代码如下：

#include <iostream>#include <functional>int main() { std::minus<int> subtract_int; std::minus<double> subtract_double; int a = 1, b = 2; double x = 1.5, y = 2.5; std::cout << 'subtract_int(a, b) = ' << subtract_int(a, b) << std::endl; std::cout << 'subtract_double(x, y) = ' << subtract_double(x, y) << std::endl; return 0;}

输出结果为：

subtract_int(a, b) = -1subtract_double(x, y) = -1

1. std::multiplies：乘法函数符

std::multiplies也是一个二元函数对象，用于实现乘法运算。当输入为两个整数时，返回的结果也是整数类型；当输入为两个浮点数时，返回的结果也是浮点数类型。示例代码如下：

#include <iostream>#include <functional>int main() { std::multiplies<int> multiply_int; std::multiplies<double> multiply_double; int a = 2, b = 3; double x = 2.5, y = 3.5; std::cout << 'multiply_int(a, b) = ' << multiply_int(a, b) << std::endl; std::cout << 'multiply_double(x, y) = ' << multiply_double(x, y) << std::endl; return 0;}

输出结果为：

multiply_int(a, b) = 6multiply_double(x, y) = 8.75

1. std::divides：除法函数符

std::divides也是一个二元函数对象，用于实现除法运算。当输入为两个整数时，返回的结果为整数类型；当输入为两个浮点数时，返回的结果也是浮点数类型。示例代码如下：

#include <iostream>#include <functional>int main() { std::divides<int> divide_int; std::divides<double> divide_double; int a = 6, b = 3; double x = 5.5, y = 2.5; std::cout << 'divide_int(a, b) = ' << divide_int(a, b) << std::endl; std::cout << 'divide_double(x, y) = ' << divide_double(x, y) << std::endl; return 0;}

输出结果为：

divide_int(a, b) = 2divide_double(x, y) = 2.2

1. std::modulus：取模运算函数符

std::modulus也是一个二元函数对象，用于实现取模运算。当输入为两个整数时，返回的结果为整数类型。示例代码如下：

#include <iostream>#include <functional>int main() { std::modulus<int> mod_int; int a = 7, b = 3; std::cout << 'mod_int(a, b) = ' << mod_int(a, b) << std::endl; return 0;}

输出结果为：

mod_int(a, b) = 1

1. std::negate：取反函数符

std::negate是一个一元函数对象，用于实现取反运算。当输入为一个整数时，返回的结果也是整数类型；当输入为一个浮点数时，返回的结果也是浮点数类型。示例代码如下：

#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。

1. 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; // 输出 5    return 0;}

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

1. 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; // 输出 5    return 0;}

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

1. 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; // 输出 5    return 0;}

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

1. 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++中，我们可以自定义函数符和函数适配器来满足特定的需求。下面将分别介绍如何自定义函数符和函数适配器。

首先，自定义函数符需要满足以下条件：

1. 函数符必须是一个struct或class类型。
2. 函数符必须重载operator()，并且参数和返回值类型必须与其它函数符和函数适配器兼容。
3. 函数符应该符合可调用对象的要求，这意味着它可以像函数一样被调用。

下面是一个简单的自定义函数符的示例代码：

struct MyFunc { int operator()(int x, int y) const { return x + y; }};

这个函数符可以将两个整数相加并返回它们的和。我们可以像使用其它函数符一样使用它：

MyFunc func;int result = func(2, 3); // result = 5

接下来，让我们来看一下如何自定义函数适配器。自定义函数适配器可以用于将一个函数对象适配成另一个函数对象，以满足特定的需求。下面是一个示例代码，说明如何自定义一个简单的函数适配器：

template<typename T>struct MyAdapter { MyAdapter(T func) : func_(func) {} int operator()(int x, int y) const { return func_(x, y); } T func_;};

这个函数适配器接受一个函数对象作为参数，并将它适配成一个接受两个整数参数并返回一个整数的函数对象。我们可以像使用其它函数适配器一样使用它：

MyFunc func;MyAdapter<MyFunc> adapter(func);int result = adapter(2, 3); // result = 5

以上就是自定义函数符和函数适配器的基本方法。需要注意的是，我们应该根据具体的需求来设计自己的函数符和函数适配器，并确保它们与标准库中的函数符和函数适配器兼容。