[C++11#47] (四) function包装器 | bind 函数包装器 | 结合使用

目录

一. function包装器

1. 在题解上

 2.bind 绑定

1.调整参数顺序

2.对类中函数的包装方法

---

一. function包装器

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

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

如何实现对函数传参的三种统一模板化调用？包装器

解决了：模板调用函数的效率低下，实例化多份的问题

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(function<double(double)>(f), 11.11) << endl;

	// 函数对象
	Functor  ft;
	cout << useF(function<double(double)>(ft), 11.11) << endl;

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

	return 0;
}

实现了对象对 同类型 的不同函数处理的便捷调用，再也不用创建多个了，实现了优化

1. 在题解上

以150. 逆波兰表达式求值为例

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> _st;
        map<string,function<int(int,int)>> opFuncMap = 
        {
            {"+",[](int x,int y)->int{return x+y;}},
            {"-",[](int x,int y)->int{return x-y;}},
            {"*",[](int x,int y)->int{return x*y;}},
            {"/",[](int x,int y)->int{return x/y;}},
            //这里还可以添加%其他东西，还是很好用的

        };

        for(auto& str : tokens)
        {
            if(opFuncMap.count(str) == 0)
            {
                _st.push(stoi(str));
            }
            else
            {
                int right=_st.top();
                _st.pop();
                int left=_st.top();
                _st.pop();

                _st.push(opFuncMap[str](left,right));
            }
        }
        return _st.top();
    }
};

---

 2.bind 绑定

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

使用

• bind，第一个参数传的是可调用对象
• placeholders

placeholders是一个命名空间，里面定义了很多_1,_2,_3等等，这些东西是一个占位对象。绑定后如果需要自己传参数，_1代表要传的第一个参数，_2代表要传的第二个参数

可以结合如下代码理解：

1.调整参数顺序

例如说调用银行的不同利率

double Plus(int a, int b, double rate)
{
	return (a + b) * rate;
}

double PPlus(int a, double rate, int b)
{
	return  rate*(a + b);
}
int main()
{
	function<double(int, int)> Plus1 = bind(Plus, placeholders::_1, placeholders::_2, 4.0);
	function<double(int, int)> Plus2 = bind(Plus, placeholders::_1, placeholders::_2, 4.2);
	function<double(int, int)> Plus3 = bind(Plus, placeholders::_1, placeholders::_2, 4.4);

	cout << Plus1(5, 3) << endl;
	cout << Plus2(5, 3) << endl;
	cout << Plus3(5, 3) << endl;

    //PPlus    
    function<double(int, int)> PPlus1 = bind(PPlus, placeholders::_1, 4.0, placeholders::_2);
	function<double(int, int)> PPlus2 = bind(PPlus, placeholders::_1, 4.2, placeholders::_2);
	cout << PPlus1(5, 3) << endl;
	cout << PPlus2(5, 3) << endl;

}

• 注意：对 PPlus 而言，是 _1,_2 不是 _2,_3
• 重申：_1代表要传的第一个参数，_2代表要传的第二个参数
• 打印：

2.对类中函数的包装方法

两种写法：

1. Sub st; bind(&Sub::sub,&st, ..)
2. bind(&Sub::sub, Sub(), ..)

取函数地址后，再传个对象/对象的指针

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b * x;
	}
private:
	int x = 20;
};


int main()
{
	//绑定固定参数
	//类成员函数多了一个参数，每次调用都需要在前面传一个对象然后才能调用
	function<int(Sub, int, int)> func4 = &Sub::sub;
	cout << func4(Sub(), 10, 20) << endl;
	

	function<int(int, int)> func5 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func5(10, 20) << endl;

	return 0;
}

Bind 此处的调用的内部：还是一个 operate()的仿函数，相当于对类函数的提取

sum:

function 是想对各种可调用对象函数指针、函数对象，lambda进行适配包装给一个统一的类型。

bind 是对可调用的对象的参数进行包装绑定，然后调整，绑死。