＜ lambda表达式与包装器＞——《C++高阶》

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

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;
	};
	r2(10000, 2);
	return 0;
}

从使用方式上来看，函数对象与lambda表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。 实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

 

定义一个lambda，编译器会在底层生成一个仿函数。再去调用这个生成色仿函数。 

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

ret = func(x);
// 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
//是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
//为什么呢？我们继续往下看
template 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函数模板实例化了三份。 包装器可以很好的解决上面的问题

std::function在头文件
// 类模板原型如下
template  function;     // undefined
template 
class function;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

// 使用方法如下：
#include 
int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
class Plus
{
public:
	//静态的包装后就能用
	static int plusi(int a, int b)
	{
		return a + b;
	}
	//非静态的含有this指针，包装后需要加上类名
	double plusd(double a, double b)
	{
		return a + b;
	}
};
int main()
{
	// 函数名(函数指针)
	std::function func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	std::function func2 = Functor();
	cout << func2(1, 2) << endl;
	// lamber表达式
	std::function func3 = [](const int a, const int b)
	{return a + b; };
	cout << func3(1, 2) << endl;

	// 类的成员函数
	std::function func4 = &Plus::plusi;
	cout << func4(1, 2) << endl;
	std::function func5 = &Plus::plusd;
	cout << func5(Plus(), 1.1, 2.2) << endl;
	return 0;
}

 

有了包装器，如何解决模板的效率低下，实例化多份的问题呢？

#include 
template 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 func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 函数对象
	std::function func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// lamber表达式
	std::function func3 = [](double d)->double { return d / 4; };
	cout << useF(func3, 11.11) << endl;
	return 0;
}

总结：

可调用的对象：

1.函数指针

2.仿函数

3.lambda

2.2例题练习： 逆波兰表达式：

class Solution 
{
public:
	int evalRPN(vector& tokens) 
	{
		stack st;
		for (const auto& str : tokens)
		{
			if (str == "+" || str == "-"
				|| str == "*" || str == "/")
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				switch (str[0])
				{
				case '+':
					st.push(left + right);
					break;
				case '-':
					st.push(left - right);
					break;
				case '*':
					st.push(left * right);
					break;
				case '/':
					st.push(left / right);
					break;
				default:
					break;
				}
			}
			else
			{
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};

 

class Solution {
public:
	int evalRPN(vector& tokens) {
		stack st;
		for (auto& str : tokens)
		{
			if (str == "+" || str == "-" || str == "*" || str == "/")
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				switch (str[0])
				{
				case '+':
					st.push(left + right);
					break;
				case '-':
					st.push(left - right);
					break;
				case '*':
					st.push(left * right);
					break;
				case '/':
					st.push(left / right);
					break;
				}
			}
			else
			{
				// 1、atoi itoa
				// 2、sprintf scanf
				// 3、stoi to_string C++11
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};
// 使用包装器以后的玩法
class Solution {
public:
	int evalRPN(vector& tokens) {
		stack st;
		map> opFuncMap =
		{
		{ "+", [](int i, int j) {return i + j; } },
		{ "-", [](int i, int j) {return i - j; } },
		{ "*", [](int i, int j) {return i * j; } },
		{ "/", [](int i, int j) {return i / j; } }
		};
		for (auto& str : tokens)
		{
			if (opFuncMap.find(str) != opFuncMap.end())
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				st.push(opFuncMap[str](left, right));
			}
			else
			{
				// 1、atoi itoa
				// 2、sprintf scanf
				// 3、stoi to_string C++11
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};

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

// 原型如下：
template 
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2) 
template 
/* 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为第二个参数，以此类推。

// 使用举例
#include 
int Plus(int a, int b) 
{
	return a + b;
}
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	std::function func1 = std::bind(Plus, placeholders::_1,
		placeholders::_2);
	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
	//func2的类型为 function 与func1类型一样
	//表示绑定函数 plus 的第一，二为： 1， 2
	auto  func2 = std::bind(Plus, 1, 2);
	cout << func1(1, 2) << endl;
	cout << func2() << endl;
	Sub s;
	// 绑定成员函数
	std::function func3 = std::bind(&Sub::sub, s,
		placeholders::_1, placeholders::_2);
	// 参数调换顺序
	std::function func4 = std::bind(&Sub::sub, s,
		placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	cout << func4(1, 2) << endl;
	return 0;
}

举例：

 

#include 
int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
class Plus
{
public:
	Plus(int x=2)
		:_x(x)
	{}

    int plusi(int a, int b)
	{
		return (a + b)*2;
	}
private:
	int _x;
};
int main()
{
	// 函数名(函数指针)
	std::function func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	std::function func2 = Functor();
	cout << func2(10, 20) << endl;
	
	std::function func5 = &Plus::plusi;
	cout << func5(Plus(), 100, 200) << endl;


	return 0;
}

 

 

 

 

int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
class Plus
{
public:
	Plus(int x=2)
		:_x(x)
	{}

    int plusi(int a, int b)
	{
		return (a + b)*_x;
	}
private:
	int _x;
};
int main()
{
	// 函数名(函数指针)
	std::function func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	std::function func2 = Functor();
	cout << func2(10, 20) << endl;
	
	//1.直接包装的是3个参数
	std::function func3 = &Plus::plusi;
	cout << func3(Plus(), 100, 200) << endl;

	//2.1 bind绑定，调整了个数，为2个参数
	std::function func4 = std::bind(&Plus::plusi,Plus(10),
		placeholders::_1,placeholders::_2);
	//第一个对象Plus(10)已经绑死，后面两个对象占位placeholders::_1,placeholders::_2是显式传参，占位
	cout << func4(100, 200) << endl;

	//2.2 bind绑定，调整了个数，为1个参数
	std::function func5 = std::bind(&Plus::plusi, Plus(10),15, placeholders::_1);
	//第一个Plus(10)、第二个对象15已经绑死，后面一个对象占位placeholders::_1是显式传参，占位
	cout << func5( 200) << endl;

	return 0;
}

 第一个func3是显式传参，显式用的是匿名对象Plus(),没有传参数就用缺省参数2
第二个func4没有传Plus对象，因为bind绑定相当于包了一层传给function，可以认为把参数给调整了。第一个参数Plus（10）已经传了，相当于写死了。传的就是10，其实内部还是用Plus去调用！
绑定可以调整可调用对象的参数个数和顺序！
Func3直接包装是3个参数！
Func4bind绑定调整为2个参数！
_1、_2、_3表示要自己传的参数

 

 

 

 

#include
#include 
#include
#include 
#include

 总结：bind绑定可以调整参数个数和参数传参顺序！