C++笔记---包装器

🕗 发布于 2024-11-10 18:51 笔记

1. 什么是包装器

C++中的包装器是一种设计模式，用于将一个复杂或底层的接口进行封装，以便提供一个更简洁、易用的接口。包装器可以包装任何类型的可调用实体，如函数，成员函数，函数指针，仿函数对象，lambda表达式等。

包装器在资源管理、接口封装、类型安全等方面有广泛应用。

在实际编程中，包装器可以用于回调机制、事件处理、异步编程等场景。它们提供了灵活的函数调用机制，使得代码更加模块化和可重用。

综上所述，C++包装器是提升代码可读性、可维护性和性能的有力工具。通过使用标准库(<functional>头文件)中提供的包装器类，开发者可以更方便地处理各种可调用对象。

2. function

在C++标准库中，std::function是一个模板类，它用作一个通用的函数包装器，能够存储、复制和调用任何可调用的目标。

template <class T>
class function; 

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

2.1 包装非成员函数

在对可调用对象进行包装的时候，需要在类型参数列表中指定可调用对象的返回值和参数列表：

#include<functional>
#include<iostream>
using namespace std;

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

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

int main()
{
// 包装各种可调用对象
function<int(int, int)> f1 = f;
function<int(int, int)> f2 = Functor();
function<int(int, int)> f3 = [](int a, int b) {return a + b; };
cout << f1(1, 1) << endl;
cout << f2(1, 1) << endl;
cout << f3(1, 1) << endl;

return 0;
}

可以认为是编译器对包装器做的特殊处理吧。

2.2 成员函数

与普通函数不同的是，不能直接使用成员函数的函数名来进行包装，必须对其进行取地址(&)。

注意：(1) 访问成员函数要指定类域；(2) 普通成员函数的参数列表中有隐含的this指针。

#include<functional>
#include<iostream>
using namespace std;

class Plus
{
public:
Plus(int n = 10)
: _n(n)
{}
static int plusi(int a, int b)
{
return a + b;
} 
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};

int main()
{
// 包装静态成员函数
// 成员函数要指定类域并且前面加&才能获取地址
function<int(int, int)> f4 = &Plus::plusi;
cout << f4(1, 1) << endl;

// 包装普通成员函数
// 普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以
function<double(Plus*, double, double)> f5 = &Plus::plusd;
Plus pd;
cout << f5(&pd, 1.1, 1.1) << endl;
function<double(Plus, double, double)> f6 = &Plus::plusd;
cout << f6(pd, 1.1, 1.1) << endl;
cout << f6(pd, 1.1, 1.1) << endl;
function<double(Plus&&, double, double)> f7 = &Plus::plusd;
cout << f7(move(pd), 1.1, 1.1) << endl;
cout << f7(Plus(), 1.1, 1.1) << endl;

return 0;
}

2.3 逆波兰表达式求值. - 力扣（LeetCode）

在学习function之前，我们可以使用switch语句来建立运算符与运算逻辑之间的关系：

// 传统方式的实现
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> 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
{
st.push(stoi(str));
}
}
return st.top();
}
};

在学习function之后，我们可以使用map来建立二者的关系：

// 使用map映射string和function的方式实现
// 这种方式的最大优势之一是方便扩展，假设还有其他运算，我们增加map中的映射即可
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> st;
// function作为map的映射可调用对象的类型
map<string, function<int(int, int)>> opFuncMap = {
{"+", [](int x, int y) {return x + y; }},
{"-", [](int x, int y) {return x - y; }},
{"*", [](int x, int y) {return x * y; }},
{"/", [](int x, int y) {return x / y; }}
};
for(auto & str : tokens)
{
if (opFuncMap.count(str)) // 操作符
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
int ret = opFuncMap[str](left, right);
st.push(ret);
} 
else
{
st.push(stoi(str));
}
} 
return st.top();
}
};

之前无法使用这样的方式来做的原因是：各个lambda表达式(或其他可调用对象)的类型不一样，导致这些lambda表达式无法放到同一个map中进行管理。

可以说，function包装器的一大作用就是可以将返回值和参数列表相同的一类可调用对象的类型统一起来，方便传参或存储。

3. bind

std::bind也是C++标准库中的一个包装器，它的主要作用是将一个可调用对象的参数进行调整，生成并返回一个新的可调用对象。

// 不显示指定返回类型，编译器自动推导
template <class Fn, class... Args>
typename std::result_of<Fn(Args...)>::type bind(Fn&& fn, Args&&... args);

// 显式指定返回类型
template <class Ret, class Fn, class... Args>
Ret bind(Fn&& fn, Args&&... args);

std::bind的主要作用有两个：

(1)指定某个参数的值并绑定到新的可调用对象。

(2)调整参数的顺序。

Args是一个占位符列表，用于在绑定时指定传递给可调用对象的参数。

这些占位符可以是实际的参数值，也可以是std::placeholders命名空间中定义的占位符，如std::placeholders::_1、std::placeholders::_2等，它们在后续的调用中会被实际传递的参数所替代。

3.1 调整参数顺序

利用std::placeholders命名空间中定义的占位符，我们可以对参数的顺序进行调整。

_1、_2、...、_n分别代表原函数中的第1个参数、第2个参数、...、第n个参数。

在bind的参数列表中按我们需要的顺序给出这些占位符，就可以实现参数顺序的调整：

#include<functional>
#include<iostream>
using namespace std;
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;

int Sub(int a, int b)
{
return (a - b) * 10;
}

int main()
{
    // bind 本质返回的一个仿函数对象
// 调整参数顺序（不常用）
// _1代表第一个实参
// _2代表第二个实参
// ...

    // 10->_1(对应a), 5->_2(对应b), 结果为50
auto sub1 = bind(Sub, _1, _2);
cout << sub1(10, 5) << endl;

    // 10->_2(对应b), 5->_1(对应a), 结果为-50
auto sub2 = bind(Sub, _2, _1);
cout << sub2(10, 5) << endl;

return 0;
}

3.2 绑定参数

当占位符是实际的参数值时，对应位置的参数的值会被绑定为该实际值：

#include<functional>
#include<iostream>
using namespace std;
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;

int Sub(int a, int b)
{
return (a - b) * 10;
}

int SubX(int a, int b, int c)
{
return (a - b - c) * 10;
}

class Plus
{ 
public:
static int plusi(int a, int b)
{
return a + b;
} 
double plusd(double a, double b)
{
return a + b;
}
};

int main()
{
// 调整参数个数
auto sub3 = bind(Sub, 100, _1);
cout << sub3(5) << endl;
auto sub4 = bind(Sub, _1, 100);
cout << sub4(5) << endl;
// 分别绑死第123个参数
auto sub5 = bind(SubX, 100, _1, _2);
cout << sub5(5, 1) << endl;
auto sub6 = bind(SubX, _1, 100, _2);
cout << sub6(5, 1) << endl;
auto sub7 = bind(SubX, _1, _2, 100);
cout << sub7(5, 1) << endl;

// 成员函数对象进行绑定，就不需要每次都传递了
function<double(Plus&&, double, double)> f6 = &Plus::plusd;
Plus pd;
cout << f6(move(pd), 1.1, 1.1) << endl;
cout << f6(Plus(), 1.1, 1.1) << endl;

// bind一般用于绑定一些固定参数
function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
cout << f7(1.1, 1.1) << endl;

// 计算复利的lambda
auto func1 = [](double rate, double money, int year)->double {
double ret = money;
for (int i = 0; i < year; i++)
{
ret += ret * rate;
} 
return ret - money;
};
// 绑定一些参数，实现出支持不同年华利率，不同⾦额和不同年份计算出复利的结算利息
function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);
cout << func3_1_5(1000000) << endl;
cout << func5_1_5(1000000) << endl;
cout << func10_2_5(1000000) << endl;
cout << func20_3_5(1000000) << endl;

return 0;
}

注意：某参数被绑定之后，占位符的对应关系中不再考虑该参数，而是对剩下的参数依次编号为_1、_2、...、_n-1，多个参数被绑定时同理。

原文地址：https://blog.csdn.net/2302_80372340/article/details/143661772

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：C语言数组，局部全局变量，数组注意事项
下一篇：Spring学习笔记(三)

JVM学习路径
JVM学习
阅读更多2024-11-13
鸿蒙进阶篇-属性动画-animateTo&转场动画
大家好啊，这里是鸿蒙开天组，今天我们来学习属性动画-animateTo&转场动画，咱们先来学习属性动画-animateTo。
阅读更多2024-11-13
docker之容器设置开机自启（4）
要确保 Docker 容器在服务器重启后自动启动，并在容器出现故障时自动重启，可以使用 Docker 的内置 --restart 策略。这种设置可以提升容器的可用性，尤其是在生产环境中
阅读更多2024-11-13
css2D变换用法
CSS 2D变换是CSS3引入的一组功能，允许开发者在二维空间内对HTML元素进行移动、旋转、缩放和倾斜等操作。这些变换只是视觉上改变元素的呈现方式，并不会影响其在文档流中的位置或大小。本文将详细介绍
阅读更多2024-11-13
【划分型DP-最优划分】力扣LCR 165. 解密数字
这道题和将字母翻译为数字的逻辑一样，我们只需要定义dp[i]为前i个字符组成的字符串所能解密的字母个数。然后我们开始遍历i，以第i个字符和第i-1个字符进行讨论，当curNum是0-5之间的时候，并且
阅读更多2024-11-13
LeetCode 93-复制 IP地址
【代码】LeetCode 93-复制 IP地址。
阅读更多2024-11-13
SpringBoot下Bean的单例模式详解
希望本文的介绍和示例能帮助你在 Spring Boot 项目中更好地管理和使用单例模式
阅读更多2024-11-13
酷炫的鼠标移入效果(附源码!!)
欢迎大家关注[小白讲前端]
阅读更多2024-11-13
【计算机网络】设备如何监听 ARP 请求广播
在网络通信中，**ARP（地址解析协议）**用于将网络层的 IP 地址解析为链路层的物理地址（MAC 地址）。当一个设备需要发送 IP 数据包时，它需要知道目标设备的 MAC 地址，这时它会发送一个。
阅读更多2024-11-13
7thonline第七在线出席FASHION PRO 30菁英对话：时尚行业深度洞察
赵嘉程表示，AI在时尚行业的应用正逐步深化，它不仅能够提升设计效率，优化生产流程，还能为消费者提供更加个性化、智能化的购物体验。未来，7thonline第七在线将继续致力于时尚科技领域的研发和创新，特
阅读更多2024-11-13