C++11——包装器

文章目录

C++11——包装器
一、function包装器
二、bind包装器

一、function包装器

1.function包装器的引入

来看这样一行代码：
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, 2.2) << endl;
	//函数对象
	cout << useF(Functor(), 2.2) << endl;
	//lambda表达式
	cout << useF([](double d)->double{
     
      return d / 4; }, 2.2) << endl;
	return 0;
}
通过上面的程序验证，我们会发现useF函数模板实例化了三份。每份count的地址都是不一样的。有没有办法让useF函数模板只实例化一份呢？为了让可调用的类型统一起来，C++11引入了function包装器来解决。

2.function包装器的概念

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

function类模板的原型如下：

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

模板参数说明：

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

有了function包装器，就可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。示例：

#include <functional>
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;
	}
	double plusd(double a, double b)
	{
     
     
		return a + b;
	}
};
int main()
{
     
     
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;//3
	// 仿函数
	std::function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;//3
	// lambda表达式
	std::function<int(int, int)> func3 = [](int a, int b) {
     
     return a + b; };
	cout << func3(1, 2) << endl;//3
	//类的静态成员函数
	std::function<int(int, int)> func4 = Plus::plusi;//非静态成员函数必须加&，静态可不加
	cout << func4(1, 2) << endl;//3
	//类的非静态成员函数
	std::function<double(Plus, double, double)> func5 = &Plus::plusd;//非静态成员函数必须加&，静态可不加
	cout << func5(Plus(), 1.1, 2.2) << endl;//3.3
	return 0;
}

注意：

类的成员函数在包装的时候记得指定类域
类的非静态成员函数必须加&，静态成员函数可加可不加
类的非静态成员函数存在隐含的this指针，包装的时候要多增加一个参数（类名），调用的时候多传一个类的匿名对象

3.使用function包装器优化逆波兰表达式求值

来看leetcode上这样一道题：逆波兰表达式求值

解决此题的步骤如下：

定义一个栈，遍历此数组
遍历到数字直接push入栈
若遍历到的字符串不是数字（“+”、“-”、“*”、"/"其中任意一个字符串），取栈顶的两个元素进行对应的算数运算，并把结果再push入栈。
遍历结束，最终栈顶的元素就是最终的值

代码如下：

class Solution {
     
     
public:
    int evalRPN(vector<string>& tokens) {
     
     
        stack<int> st;
        for (int i = 0; i < tokens.size(); i++)
        {
     
     
            if (!(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"))
            {
     
     
                st.push(stoi(tokens[i]));
            }
            else
            {
     
     
                int num1 = st.top();
                st.pop();
                int num2 = st.top();
                st.pop();
                if (tokens[i] == "+")
                    st.push(num1 + num2);
                else if (tokens[i] == "-")
                    st.push(num2 - num1);
                else if (tokens[i] == "*")
                    st.push((long)num1 * num2);
                else if (tokens[i] == "/")
                    st.push(num2 / num1);
            }
        }
        return st.top();
    }
};

上述代码中，我主要是通过if、else语句来判断其进行何种运算，若后续运算类型增加了，那么还要增加if、else语句，多少有点冗余，我们可以使用包装器来优化此代码。

优化规则如下：

这里我们可以利用包装器建立操作符和对应函数的映射关系，这一步需要用到map容器，在列表初始化中对每个操作符完成对应的函数映射关系
遍历数组，判断字符是否在map容器里头，如果在，说明是操作符，取栈顶的两个元素，进行相应的运算后，把结果push到栈里。
若字符不在map容器里头，说明是操作数，直接入栈
遍历结束，最后直接返回栈顶的元素
注意要防止栈溢出，要用long long的类型

class Solution {
     
     
public:
    int evalRPN(vector<string>& tokens) {
     
     
        stack<long long> st;
        map<string, function<long long(long long, long long)>> opFuncMap = 
        {
     
     
            {
     
     "+", [](long long x, long long y){
     
     return x + y;}},
            {
     
     "-", [](long long x, long long y){
     
     return x - y;}},
            {
     
     "*", [](long long x, long long y){
     
     return x * y;}},
            {
     
     "/", [](long long x, long long y){
     
     return x / y;}}
        };
        for (auto& str : tokens)
        {
     
     
            if (opFuncMap.count(str))//判断操作符是否在opFuncMap
            {
     
     
                long long right = st.top();
                st.pop();
                long long left = st.top();
                st.pop();
                st.push(opFuncMap[str](left, right));
            }
            else//操作数
            {
     
     
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

4.使用function包装器解决模板效率地下，实例化多份的问题

在一开始我们引入包装器时，提出了传不同的类型，要实例化三份，导致模板效率低下，现在我不再直接传函数指针、lambda……了，相反用包装器将其包装起来就解决此问题了：

#include <functional>
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;
}

此时会发现只实例化了一份，count的地址始终是一样的，所以静态成员变量自然在累加。由此可见，包装器统一了类型。

5.function包装器的意义

将可调用对象的类型进行统一，便于我们对其进行统一化管理。

包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。

二、bind包装器

1.bind包装器的引入

看如下的代码：
#include <functional>
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;
};
非静态成员函数是有隐含的this指针的，所以在包装plusi函数的时候得多传一个参数（共3个），这是我们前面讲过的，而Functor和f仅需传2个参数即可：
int main()
{
     
     
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;//3
	// 仿函数
	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;//30
	//类的非静态成员函数
	std::function<double(Plus, int, int)> func3 = &Plus::plusi;//非静态成员函数必须加&，静态可不加
	cout << func3(Plus(), 100, 200) << endl;//300.22
}
假设我现在利用包装器建立字符串和对应函数的映射关系，并放到map容器里面，此时就会出现问题了：成员函数会有三个参数，而我map容器里的value位置仅允许传两个参数，导致参数无法匹配：

为了解决此问题，就需要用到我们下面的bind包装器。

2.bind包装器的概念

bind包装器概念：

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

bind函数模板原型如下：
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
模板参数说明：

fn：可调用对象

args…：要绑定的参数列表（值或占位符）

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

callable：需要包装的可调用对象。

newCallable：本身是一个可调用对象

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

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

3.bind包装器绑定调整参数个数

绑定普通函数：
int Plus(int a, int b)
{
     
     
	return a + b;
}
int main()
{
     
     
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
    	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;//3
}
绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_ 1和placeholders::_ 2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_ 1，传入的第二个参数传给placeholders::_ 2。此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，也可以称之为无意义的绑定趴

调整参数个数：

我可以把Plus函数的第二个参数固定绑定为20，只需要把参数列表的placeholders::_2设置为20即可，此时调用绑定后新生成的可调用对象时就只需要传入一个参数。如下：
int Plus(int a, int b)
{
     
     
	return a + b;
}
int main()
{
     
     
	//表示绑定函数 plus 的第2个参数为20
    std::function<int(int)> func2 = std::bind(Plus, placeholders::_1, 20);
	cout << func2(5) << endl;//25
}
绑定成员函数：
class Plus
{
     
     
public:
	Plus(int x = 2)
		:_x(x)
	{
     
     }
	int plusi(int a, int b)
	{
     
     
		return (a + b) * _x;
	}
private:
	int _x;
};
int main()
{
     
     
	//未绑定，需要传3个参数
	std::function<int(Plus, int, int)> func1 = &Plus::plusi;
	cout << func1(Plus(), 100, 200) << endl;//600
	//绑定后，仅需传2个参数
	std::function<int(int, int)> func2 = std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2);
	cout << func2(100, 200) << endl;//3000
	//绑定指定参数，func3的第一个参数已被指定，仅需传1个参数
	std::function<int(int)> func3 = std::bind(&Plus::plusi, Plus(10), 15, placeholders::_1);
	cout << func3(25) << endl;//400
	return 0;
}
通过func1、func2、func3的对比，很明显我func1是直接包装的，需要传3个参数（其中一个隐含的this指针），func2绑定调整过后，也就是把Plus()绑定了，调用时会固定帮我们传一个匿名对象给this指针，也就只需要传2个参数；我func3是绑定调整指定参数，func3的第一个参数已被指定为15，只需要传1个参数即可。

下面来解决一开始引入bind时出现参数个数不匹配的问题：

解决此问题，我们只需要使用绑定来调整参数个数即可：
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()
{
     
     
	map<string, std::function<int(int, int)>> opFuncMap =
	{
     
     
		{
     
      "普通函数指针", f },
		{
     
      "函数对象", Functor()},
		{
     
      "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2)}
	};
	cout << opFuncMap["普通函数指针"](1, 2) << endl;//3
	cout << opFuncMap["函数对象"](10, 20) << endl;//30
	cout << opFuncMap["成员函数指针"](100, 200) << endl;//3000
	return 0;
}
此时成员函数指针绑定调整过后，也就是把Plus()绑定了，调用时会固定帮我们传一个匿名对象给this指针，也就只需要传2个参数，就不会出现参数不匹配的情况了。

4.bind包装器绑定调整参数顺序

对于如下的Sub类的成员函数sub，第一个参数为隐含的this指针，如果想要在调用Sub成员函数时不用对象进行调用this指针，我们可以将sub成员函数的第一个参数固定绑定为一个Sub对象。比如：
class Sub
{
     
     
public:
	int sub(int a, int b)
	{
     
     
		return a - b;
	}
};
int main()
{
     
     
	std::function<int(int, int)> func1 = std::bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;//-1
	return 0;
}
此时只需要传用于两个相减的参数了，因为在调用时会固定帮我们传一个匿名对象给this指针。

下面如果我想交换两个相减参数的顺序，只需要在绑定时把placeholders::_ 1和placeholders::_ 2的位置交换一下即可：
class Sub
{
     
     
public:
	int sub(int a, int b)
	{
     
     
		return a - b;
	}
};
int main()
{
     
     
	//调整顺序
	std::function<int(int, int)> func2 = std::bind(&Sub::sub, Sub(), placeholders::_2, placeholders::_1);
	cout << func2(1, 2) << endl;//1
	return 0;
}
此时实参1传给_ 2，也就是第二个参数，实参2传给_1，也就是第一个参数，2-1=1。

5.bind包装器的意义

将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。

可以对函数参数的顺序进行灵活调整。

【C++11】包装器