C++11 ------- 包装器

GSX_M

已于 2022-09-20 21:42:23 修改

阅读量251

点赞数 1

分类专栏： C++ 文章标签： c++

于 2022-09-20 21:35:37 首次发布

本文链接：https://blog.csdn.net/m0_52169086/article/details/126959210

版权

C++ 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

3.bind包装器调整传参顺序(用的不多)

4.bind包装器的意义

function包装器

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

1.为什么需要包装器

(1) 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, 22.22) << endl;

 // 函数对象
 cout << useF(Functor(), 33.33) << endl; //匿名对象

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

 return 0; 
}

(2)运行结果

①发现useF函数模板实例化了三份

②解释

由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印count的地址也是不同的。
但实际这里根本没有必要实例化出三份useF函数，因为三次调用useF函数时传入的可调用对象虽然是不同类型的，但这三个可调用对象的返回值和形参类型都是相同的。
使用包装器可以解决问题

2.包装器的介绍

(1)包装器

①function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。

②function类模板的原型

template <class T> function;     // undefined

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

③模板参数说明

Ret ：被包装的可调用对象的返回值类型。
Args... ：被包装的可调用对象的形参类型。

(2)包装器使用示例

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

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()
{
	//1、包装函数指针（函数名）
	function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	//2、包装仿函数（函数对象）
	function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;

	//3、包装lambda表达式
	function<int(int, int)> func3 = [](int a, int b){return a + b; };
	cout << func3(1, 2) << endl;

	//4、类的静态成员函数
	//function<int(int, int)> func4 = Plus::plusi;
	function<int(int, int)> func4 = &Plus::plusi; //&可省略
	cout << func4(1, 2) << endl;

	//5、类的非静态成员函数
	function<double(Plus, double, double)> func5 = &Plus::plusd; //&不可省略
	cout << func5(Plus(), 1.1, 2.2) << endl;
	return 0;
}

补充:

包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。( 普通函数函数名就是函数地址，类的成员函数需要取地址 )
包装非静态成员函数需要增加一个参数，非静态成员函数需要用对象去调用；
包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。

3.function包装器统一类型

(1)包装器解决模板的效率低下

①对于函数模板useF：

传入该函数模板的第一个参数可以是任意的可调用对象，比如函数指针、仿函数、lambda表达式等。
useF中定义了静态变量count，并在每次调用时将count的值和地址进行了打印，可判断多次调用时调用的是否是同一个useF函数。

②使用包装器

用包装器分别对着三个可调用对象进行包装，然后再用这三个包装后的可调用对象来调用useF函数，这时就只会实例化出一份useF函数。
根本原因就是因为包装后，这三个可调用对象都是相同的function类型，因此最终只会实例化出一份useF函数，该函数的第一个模板参数的类型就是function类型的。

③代码

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()
{
	//函数名
	function<double(double)> func1 = f;
	cout << useF(func1,22.22) << endl;

	//函数对象
	function<double(double)> func2 = Functor();
	cout << useF(func2, 33.33) << endl;

	//lambda表达式
	function<double(double)> func3 = [](double d)->double{return d / 4; };
	cout << useF(func3, 44.44) << endl;

	return 0;
}

④结果

这时三次调用useF函数所打印count的地址就是相同的，并且count在三次调用后会被累加到3，表示这一个useF函数被调用了三次。

(2)包装器的应用场景

应用场景 : 写某一个游戏或者网络程序，都会面临着一个问题，有一个命令，这个命令是一个字符串，面对这个命令做这个动作，下一个命令做下一个动作。

1.一个游戏里面的命令可能有很多，每个命令都写成switch case，效率很低(每个命令遍历式的判断执行动作)
2.游戏里面增加了一些动作，命令变化的时候要挨个去修改代码也是不方便的问题

①求解逆波兰表达式

定义一个栈，依次遍历所给字符串。
如果遍历到的字符串是数字则直接入栈。
如果遍历到的字符串是加减乘除运算符，则从栈定抛出两个数字进行对应的运算，并将运算后得到的结果压入栈中。
所给字符串遍历完毕后，栈顶的数字就是逆波兰表达式的计算结果。

②没有包装器的代码

我们通过switch语句来判断本次需要进行哪种运算，如果运算类型增加了，比如增加了求余、幂、对数等运算，那么就需要在switch语句的后面中继续增加case语句。

class Solution {
public:
	int evalRPN(vector<string>& tokens) 
    {
		stack<int> st;
		for (const auto& str : tokens)
		{
			int left, right;
			if (str == "+" || str == "-" || str == "*" || str == "/")
			{
				right = st.top();
				st.pop();
				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();
	}
};

③增加包装器的代码

建立各个运算符与其对应需要执行的函数之间的映射关系，当需要执行某一运算时就可以直接通过运算符找到对应的函数进行执行。
当运算类型增加时，就只需要建立新增运算符与其对应函数之间的映射关系即可，不需要修改底下的代码逻辑
重点，这里建立的是运算符与function类型之间的映射关系，因此无论是函数指针、仿函数还是lambda表达式都可以在包装后与对应的运算符进行绑定。

class Solution {
public:
	int evalRPN(vector<string>& tokens) 
    {
		stack<int> st;
		unordered_map<string, function<int(int, int)>> opMap = {
			{ "+", [](int a, int b){return a + b; } },
			{ "-", [](int a, int b){return a - b; } },
			{ "*", [](int a, int b){return a * b; } },
			{ "/", [](int a, int b){return a / b; } }
		};   // 统一的列表初始化，隐士类型转换，都会转换成pair
        
        /*
        unordered_map<string, function<int(int, int)>> opMap;
        opMap["+"] = [](int a, int b){return a + b; };
        opMap["-"] = [](int a, int b){return a - b; };
        opMap["*"] = [](int a, int b){return a * b; };
        opMap["/"] = [](int a, int b){return a / b; };
        */


		for (const auto& str : tokens)
		{
			int left, right;
			if (opMap.find(str) != opMap.end())
			{
				right = st.top();
				st.pop();
				left = st.top();
				st.pop();
				st.push(opMap[str](left, right));
			}
			else
			{
				st.push(stoi(str));
			}
		}

		return st.top();
	}
};

4.function包装器的意义

将可调用对象的类型进行统一，便于我们对其进行统一化管理。
包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。

bind包装器

1.bind包装器介绍

①bind包装器

bind也是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++中的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的一般形式

调用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为第二个参数，以此类推。
此外，除了用auto接收包装后的可调用对象，也可以用function类型指明返回值和形参类型后接收包装后的可调用对象。

2.bind包装器绑定固定参数

(1)无意义的绑定

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

int main()
{
	//无意义的绑定
	function<int(int, int)> func = bind(Plus, placeholders::_1, placeholders::_2);
	cout << func(1, 2) << endl; //3
	return 0;
}

绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。
此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，所以说这是一个无意义的绑定。

(2)绑定固定参数

想把Plus函数的第二个参数固定绑定为10，可以在绑定时将参数列表的placeholders::_2设置为10
此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与10相加后的结果进行返回。

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

int main()
{
	//绑定固定参数
	function<int(int)> func = bind(Plus, placeholders::_1, 10);
	cout << func(2) << endl; //12

	return 0;
}

3.bind包装器调整传参顺序(用的不多)

①绑定固定参数

Sub类中的sub成员函数，sub成员函数的第一个参数是隐藏的this指针，如果想要在调用sub成员函数时不用对象进行调用，那么可以将sub成员函数的第一个参数固定绑定为一个Sub对象。
此时调用绑定后生成的可调用对象时，就只需要传入用于相减的两个参数了，因为在调用时会固定帮我们传入一个匿名对象给this指针

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

int main()
{
    // 通过bind调整参数个数
    
   //没有bind
	function<int(Sub, int, int)> f = &Sub::sub;
    cout << f(Sub(), 10, 3) << endl;
     
	//第一个参数就固定了，不需要传了
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func(1, 2) << endl; //-1
	return 0;
}

②更改传参顺序

如果想要将sub成员函数用于相减的两个参数的顺序交换，那么直接在绑定时将placeholders::_1和placeholders::_2的位置交换一下就行了
根本原因就是因为，后续调用新生成的可调用对象时，传入的第一个参数会传给placeholders::_1，传入的第二个参数会传给placeholders::_2，因此可以在绑定时通过控制placeholders::_n的位置，来控制第n个参数的传递位置。

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

int main()
{
	//调整传参顺序
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_2, placeholders::_1);
	cout << func(1, 2) << endl; //1
	return 0;
}