✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】【C++详解】

目录

1 包装器

1.1、function包装器

1.2、bind

1 包装器

1.1、function包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要function呢？

先看一句代码！！！

<code>auto ret = func(x);

上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lambda表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！为什么呢？我们继续往下看。

代码演示

// 函数模板

template<class F, class T>

T useF(F f, T x)

{

static int count = 0;

cout << "count:" << ++count << endl;

cout << "count:" << &count << endl;

return f(x);

}

// 普通函数

double f(double i)

{

return i / 2;

}

// 仿函数

struct Functor

{

double operator()(double d)

{

return d / 3;

}

};

int main()

{

// 函数名

cout << useF(f, 11.11) << endl;

// 函数对象

cout << useF(Functor(), 11.11) << endl;

// lamber表达式

cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;

return 0;

}

运行结果

通过上面的程序验证，我们会发现useF函数模板实例化了三份，因为count的三个地址都不一样。 

包装器可以很好的解决上面的问题！！！

function原型

<code>std::function在头文件<functional>

// 类模板原型如下

template <class T> function;     // undefined

template <class Ret, class... Args>

class function<Ret(Args...)>;

模板参数说明：

Ret: 被调用函数的返回类型

Args…：被调用函数的形参

代码演示

template<class F, class T>

T useF(F f, T x)

{

static int count = 0;

cout << "count:" << ++count << endl;

cout << "count:" << &count << endl;

return f(x);

}

double f(double i)

{

return i / 2;

}

struct Functor

{

double operator()(double d)

{

return d / 3;

}

};

int main()

{

// 普通函数

std::function<double(double)> func1 = f;

cout << useF(func1, 11.11) << endl;

// 函数对象

std::function<double(double)> func2 = Functor();

cout << useF(func2, 11.11) << endl;

// lamber表达式

std::function<double(double)> func3 = [](double d)->double { return d /

4; };

cout << useF(func3, 11.11) << endl;

return 0;

}

运行结果 

通过上面的程序验证，我们会发现useF函数模板只实例化了一份，因为count的三个地址都相同。  

包装成员函数指针

代码演示

<code>class Plus

{

public:

// 静态成员函数，没有this指针

static int plusi(int a, int b)

{

return a + b;

}

double plusd(double a, double b)

{

return a + b;

}

};

int main()

{

function<int(int, int)> f1 = &Plus::plusi;

cout << f1(1, 2) << endl;

// 有三个参数

function<double(Plus*,double, double)> f2 = &Plus::plusd;

Plus plus;

cout << f2(&plus, 1.1, 2.2) << endl;

// 不能显示传this指针，因此语法层面只要类型匹配即可

function<double(Plus, double, double)> f3 = &Plus::plusd;

cout << f3(Plus(), 1.1, 2.2) << endl;

return 0;

}

运行结果

1.2、bind

std::bind函数定义在#include<functional>头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

bind原型

<code>// 原型如下：

template <class Fn, class... Args>

/* unspecified */ bind (Fn&& fn, Args&&... args);

// with return type (2)

template <class Ret, class Fn, class... Args>

/* unspecified */ bind (Fn&& fn, Args&&... args);

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

调用bind的一般形式：auto newCallable = bind(callable,arg_list);

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

代码演示一

int Sub(int a,int b)

{

return a - b;

}

int main()

{

auto f1 = Sub;

cout << f1(10, 5) << endl;

// 调整两个参数顺序

auto f2 = bind(Sub, placeholders::_2, placeholders::_1);

cout << f2(10, 5) << endl;

cout << typeid(f1).name() << endl;

cout << typeid(f2).name() << endl;

return 0;

}

运行结果 

代码分析 

代码演示二

<code>class Sub

{

public:

int sub(int a, int b)

{

return a - b;

}

};

int main()

{

// 调整参数个数，原本三个参数，加上this指针，第一个参数用匿名对象

auto f4 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);

cout << f4(10, 5) << endl;

Sub sub;

// 第一个参数用对象地址

auto f5 = bind(&Sub::sub, &sub, placeholders::_1, placeholders::_2);

cout << f5(10, 5) << endl;

return 0;

}

运行结果

代码演示三

<code>void fx(const string& name, int x, int y)

{

cout << name << "-> [血量:" << x << ",蓝:" << y << ']' << endl;

}

int main()

{

fx("王昭君", 80, 30);

fx("王昭君", 77, 20);

fx("王昭君", 60, 0);

fx("王昭君", 30, 40);

fx("亚瑟", 90, 20);

fx("亚瑟", 77, 15);

fx("亚瑟", 40, 0);

fx("亚瑟", 2, 20);

return 0;

}

 运行结果

从代码三我们能够打印一个英雄的属性，但是调用同一个名字太冗余，可以绑定名字。

代码三优化

<code>int main()

{

// 绑定名字

auto f6 = bind(fx, "王昭君", placeholders::_1, placeholders::_2);

f6(80, 30);

f6(77, 20);

f6(60, 0);

f6(30, 40);

auto f7 = bind(fx, "亚瑟", placeholders::_1, placeholders::_2);

f7(90, 20);

f7(77, 15);

f7(40, 0);

f7(2, 20);

return 0;

}

运行结果 

除了绑定第一个参数我们还可以绑定中间的参数，比如我们可以将血量绑定成80，代码如下： 

代码演示四

<code>int main()

{

// 绑定血量

auto f8 = bind(fx, placeholders::_1, 80, placeholders::_2);

f8("武则天", 12);

f8("妲己", 33);

return 0;

}

运行结果

代码演示四也可以使用 包装器 + 绑定。 

<code>// 包装器 + 绑定

function<void(std::string,int)> f8 = bind(fx, placeholders::_1, 80, placeholders::_2);