struct Goods
{
 string _name;  // 名字
 double _price; // 价格
 int _evaluate; // 评价
 Goods(const char* str, double price, int evaluate)
 :_name(str)
 , _price(price)
 , _evaluate(evaluate)
 {}
};

这有一个类Goods，如果我们想使用sort按名字进行升序、降序排序就需要写两个仿函数；如果想按价格进行排序，又要写两个仿函数，如果按评价排序，也是两个仿函数。

随着C++语法的发展，有人觉得这种写仿函数太复杂了，每次为了实现一个 algorithm算法，都要去重新写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这都给编程带来了极大的不便。因此，C++11语法汇总出现了Lambda表达式解决这个问题。

1.2 lambda 格式

lambda表达式书写格式：

[capture-list] (parameters) mutable -> return-type {statement}

格式说明：

[capture-list]：捕捉列表。该列表总是出现在lambda函数的开始位置，编译器根据 [] 来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文种的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用于追踪返回类型形式声明函数的返回值类型，没有返回值此部分可以省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体不能省略，但可以为空。因此C++11中最简单的lambda函数为：[ ] { }；该lambda无法实现任何功能。

举例：

[ ](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; }

函数有4个部分组成：返回值，函数名，函数参数，函数体；而lambda没有函数名，多了一个捕捉列表。

可以看出 lambda 本质就是一个匿名函数。该函数无法直接被调用，如果想要直接调用，可借助 auto 将其赋值给一个变量。

使用：

1.3 lambda捕捉列表

捕捉列表描述了上下文中哪些数据可以被lambda使用，以及使用的方式传值还是传引用。

[ var ] ：表示值传递方式捕捉 var。
[ = ]：表示值传递方式捕获所有父作用域中的变量(包括 this)。
[ &var ]：表示引用传递补做变量 var 。
[ & ]：表示引用传递捕捉所有父作用域中的变量(包括 this)。
[ this ]：表示值传递方式捕捉当前的 this 指针。

注意：

父作用域指包含 lambda 函数的语句块。
语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如[ =, &a, &b ]：以引用传递的方式捕捉变量 a 和 b ，值传递方式捕捉其他所有变量。
[ & , a , this ] ：值传递方式捕捉变量 a 和 this ，引用方式捕捉其他变量。
捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如[ = , a ]：=以及以值传递的方式捕捉了所有变量，捕捉 a 重复
在块作用域以外的 lambda 函数捕捉列表必须为空。
在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译错误。
lambda表达式之间不能相互赋值，即使看起来类型相同。

多个捕捉项的例子：捕捉全部变量，a变量使用引用捕捉：

接下来我们使用lambda表达式实现两值交换。观察使用 mutable 和引用捕捉两者的区别：

a和b属于当前test函数的作用域，而创建lambda则是当前lambda表达式的作用域，故mutable只是改变了表达式作用域下的长常量属性。如果要使用mutable能改变作用域内的值，可以再采用引用传参的方式。

1.4 函数对象与lambda表达式

函数对象，又称为仿函数，既可以像函数一样使用的对象，就是累类中重载了operator()运算符的函数对象。

接下来我们来看一段代码，我们先是使用仿函数去调用，然后再使用lambda表达式进行调用，再观察其底层。

class Rate
{
public:
	Rate(double rate) : _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
}

然后我们观察其汇编代码，观察编译器是如何处理仿函数和lambda表达式的，重点观察红框内的部分，发现其规律：

横线上是仿函数调用的汇编代码，下面是调用lambda的汇编代码。

我们首先简单了解一下什么是UUID：UUID----通用唯一识别码（Universally Unique Identifier）

其实就是一串有唯一标识的字符串。

因为本质lambda就是仿函数，为了表示唯一标识，所以被编译器就将lambda处理成了一个类，命名为 lambda + UUID这种形式的仿函数。
当lambda被声明赋值给一个变量时，就相当于调用了lambda的构造函数。而当lambda被调用时，编译器就会去调用这个对象operator()。
所谓的捕捉其实就是仿函数的传参。

所以，为什么lambda表达式之间不能相互赋值的原因大家应该就理解了。

但是可以赋值给相同类型的函数指针。

void (*PF)();
int main()
{
 auto f1 = []{cout << "hello world" << endl; };
 auto f2 = []{cout << "hello world" << endl; };
 //f1 = f2;   // 编译失败--->提示找不到operator=()
 // 允许使用一个lambda表达式拷贝构造一个新的副本
 auto f3(f2);
 f3();

 // 可以将lambda表达式赋值给相同类型的函数指针
 PF = f2;
 PF();
 return 0;
}

二、包装器

2.1 包装器的引入

function包装器也叫做适配器，C++中的function本质是一个类模板，也是一个包装器。

那么我们来看看，我们为什么需要function。如以下这个例子：

ret = func(x);

上面的func可能是什么呢？

func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lambda表达式对象？所以这些都是可调用的类型，如此丰富的类型，可能会导致模板的效率低下。

接下来是这段代码的示例：

double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

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);
}

int main()
{
	// 函数名              //会调用f函数
	cout << useF(f, 11.11) << endl; 
	// 函数对象            //会调用functor()函数
	cout << useF(Functor(), 11.11) << endl;
	// lamber表达式        //会调用lambda表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	return 0;
}

main函数中三条语句都调用了useF函数，因为useF是模板参数，所以传入什么类型的就会调用该类型，因为模板的是使用时才实例化，所以这个useF函数被实例化了三份！

接下来我们运行改代码，如果是同一个函数，static count则会被累加到3，如果是实例化了三份函数，static count 每次都会是1。结果如下：

而包装器的第一个作用就是让这种情况下，该useF函数只实例化为1份。

2.2 包装器的使用

接下来看看包装器如何使用的：

std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：

Ret: 被调用函数的返回类型
Args…：被调用函数的形参

然后我们对普通函数、仿函数、lambda表达式进行包装一下。

int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};

int main()
{
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	std::function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;

	// lamber表达式
	std::function<int(int, int)> func3 = [](const int a, const int b)
	{return a + b; };
	cout << func3(1, 2) << endl;
    return 0;
}

除了可以包装普通函数、仿函数、lambda表达式，还可以包装类的静态成员函数和类的成员函数。

首先是类的静态成员函数，包装方式如下：

如果是非静态的成员函数：

因为public的静态成员函数是可以直接调用的，而非静态的成员函数我们要用对象去调用，则要使用取地址操作符(语法规定)，三处不同之处均标注出来了：

OK，现在我们来解决上面一份函数实例化三份的问题：

首先对三个函数进行包装，然后传入包装后的函数，在模板参数看来，虽然f1、f2、f3函数实现不同，但是f1、f2、f3函数都是function<double(double)>类型，，所以该模板函数因为三次调用参数类型相同，则只会实例化为一份。

2.3 包装器的运用

有了这个包装器，我们可以在实际中便可以运用到，比如之前我博客上讲过的一道LeetCode经典题：150. 逆波兰表达式求值。

正常的写法可以看我往期的博客，讲解：leetcode150/155. 逆波兰表达式求值

这里我们是讲解使用包装器如何解决这道题。

思想：

我们可以让将各种运算符进行的处理函数用lambda表达式实现，因为类型本质是相同的，我们使用包装器进行包装，让对应的运算符和对应的运算处理函数进行绑定一起放入到map中。

我们遍历数组时，如果检测到了运算符，直接调用数据调用运算符对应的处理方式即可。

这里再介绍以下map中的count接口，我们也可以在此进行使用.

因为我们将运算符都插入到Map中了，如果该操作符存在则返回1，不存在返回0。此接口也可以用于判断key在不在。其实用 find 一样可以达到该效果。

全部代码如下：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        map<string,function<long long(long long,long long )>> operaMap=
        {
            {"+",[](long long a,long long b){return a+b;}},
            {"-",[](long long a,long long b){return a-b;}},
            {"*",[](long long a,long long b){return a*b;}},
            {"/",[](long long a,long long b){return a/b;}}
        };

        for(auto& str:tokens)
        {
            //如果是运算符：
            //if(operaMap.find(str)!=operaMap.end())
            //map中的count接口,该key存在则返回1，不存在返回0，也可以用于判断key在不在
            if(operaMap.count(str))
            {
                long long right=st.top();
                st.pop();
                long long left=st.top();
                st.pop();
                //调用运算函数，
                long long temp=operaMap[str](left,right);
                //再将结果入栈
                st.push(temp);
            }
            //
            else 
            {
                st.push(stoll(str));
            }
        }
        return st.top();
    }
};

三、bind 绑定

3.1 bind的引入

现在我们有一个普通函数和成员函数有相同的参数、返回值，此时我们考虑用包装器进行包装。

当包装完普通函数后，我们想再包装成员函数时，包装的方式就不同了，因为包装类的成员函数时我们还要传入类名。

而 bind 绑定的作用就是可以帮我们调整这些参数的顺序和个数。

std::bind函数定义在头文件中，是一个函数模板，它就像一个和函数包装器(适配器)，接受一个可调用对象(callable object)，生成一个新的可调用对象来“适应”原对象的参数列表。

bind函数会返回一个可调用对象。

参数 Fn 表示待绑定的函数，Args是一个逗号分隔的参数列表，对应给定函数的参数。当我们调用bind的返回对象时，该返回值会调用 Fn函数，然后将参数列表中的参数传给 Fn 函数。

3.2 bind 的使用

bind调整参数顺序

接下来我演示一下bind的使用：

int sub(int a, int b)
{
	return a - b;
}

这里有一个函数 sub，正常我们传入实参x和y，进入sub函数对应的就是形参a和b；我们可以使用 bind 调整传入的顺序。例如下图，

这个效果就是使用bind绑定了一个函数，然后调整了其函数参数的位置，即调整了函数的形参顺序，绑定方式如下：

调整函数参数的顺序，就是调整函数内形参的顺序，但是函数外部是取不到形参的，我们就可以使用 placeholders 命名空间中的占位，让原本传到函数第一个形参上的实参，传到第二个形参上。

配合 bind 函数一起使用的占位符(在命名空间placeholders中)

这样，原本传入函数形参1的实参就传给了形参2，实参2就传给了形参1。

除了可以使用包装器的类型进行接收，图方便的话这里也是可以使用auto的，效果一样。

更想了解bind和placeholders的使用可以参考其他文献，这里主要讲解使用：C++11 bind 和 placeholders 用法

bind 补齐参数个数

接下来回到上面未解决的问题：让类的成员函数和普通函数一样被包装。

bind除了使用placeholders占位调整参数顺序，还可以传入固定的参数进行参数的补齐。

回顾这个问题，无法包装不就是因为类的成员函数进行调用时要传入类的构造函数吗，而这个构造函数又是固定的，所以我们进行bind绑定，让其默认传入构造函数，这样我们调用该函数不就跟调用普通函数一样了吗

绑定方式如下：

除了绑定这种固定传入构造函数的函数，普通函数我们也可以进行固定绑定：

不过这样的话，第三个参数就无法改变了，这里只是想介绍bind也可以在此场景使用。

到现在，普通函数和类的成员函数我们就都进行了包装，我们就可以使用map进行事件与处理函数的绑定了：

收录于

C++

标签

#c++ #开发语言

C++包装器实战：std::function与std::bind优化模板代码与回调设计在C++编程中，可调用对象（Callable Objects）是函数式编程和泛型设计的核心概念，包括函数指针、函数对象和lambda表达式等。其多样化的类型虽然提供了灵活性，但也导致了模板代码膨胀和编译效率低下等问题。为了解决这一问题，C++标准库引入了包装器（Wrappers）机制，通过类型擦除（Type Erasure）技术，将不同类型的可调用实体统一为标准化接口。以std::function为例，它作为可调用对象的通用容器，能够存储、复制和调用任何符合签名要求的对象，从而显著减少模板实例化次数，优化编阅读详情