网站负责人不是法人,wordpress的头像图标,从事网络营销的公司,建设银行网上银行登录入口#x1f525;个人主页#xff1a;Quitecoder
#x1f525;专栏#xff1a;c笔记仓 包装器#xff08;Wrapper#xff09; 是一个常见的编程设计模式#xff0c;通常用于封装或“包装”某个现有的对象、函数、数据结构或者操作#xff0c;以提供额外的功能或简化接口。…
个人主页Quitecoder
专栏c笔记仓 包装器Wrapper 是一个常见的编程设计模式通常用于封装或“包装”某个现有的对象、函数、数据结构或者操作以提供额外的功能或简化接口。在不同的上下文中包装器可能有不同的实现方式和目的但核心思想都是“将现有功能封装起来以实现更强的扩展性、易用性或者功能分离”。 目录 1.function包装器类成员函数与普通函数的区别**为什么非静态成员函数不能直接作为函数指针传递** 2.bind**基本语法****返回值****常见用法示例**1. **绑定普通函数的参数**2. **绑定成员函数**3. **绑定成员函数与对象实例**4. **使用多个占位符**5. **绑定 Lambda 表达式** 1.function包装器
function包装器 也叫作适配器。C中的function本质是一个类模板也是一个包装器。那么我们来看看我们为什么需要function呢
ret func(x);上面func可能是什么呢那么func可能是函数名函数指针函数对象(仿函数对象)也有可能是lambda表达式对象所以这些都是可调用的类型如此丰富的类型可能会导致模板的效率低下为什么呢
templateclass F, class T
T useF(F f, T x)
{static int count0;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 是一个模板函数它接受
一个函数对象 f可以是普通函数、函数对象或 Lambda 表达式。一个参数 x这个参数的类型是 T将被传递给函数对象 f。 从结果可以看出count 的值在每次调用不同 useF 时都被重置为 1且 count 的地址在每次调用中都不同。这说明 静态变量 count 并没有在多个调用之间共享状态而是每次调用 useF 都生成了一个独立的 count 变量。 为什么 count 的值和地址不共享
在模板函数中静态变量的生命周期是与模板实例相关联的。这意味着每次为不同的模板参数组合生成一个模板实例时静态变量 count 都是独立的。
模板实例化的过程 在第一次调用 useF(f, 11.11) 时模板参数 F 被推导为 double (*)(double)函数指针T 被推导为 double。这会实例化一个 useFdouble (*)(double), double 模板函数。 对应的 count 是 useFdouble (*)(double), double 的静态变量值为 1地址为 0056B428。 在调用 useF(Functor(), 11.11) 时模板参数 F 被推导为 FunctorT 仍然是 double。这会实例化另一个独立的模板函数 useFFunctor, double。 对应的 count 是 useFFunctor, double 的静态变量值为 1地址为 0056B42C。 在调用 useF([](double d) - double { return d / 4; }, 11.11) 时模板参数 F 被推导为一个特定的 Lambda 类型Lambda 表达式的类型是匿名的T 为 double。这又会实例化一个新的模板函数 useFLambdaType, double。 对应的 count 是 useFLambdaType, double 的静态变量值为 1地址为 0056B430。
静态变量在模板中的作用域
每个模板实例的静态变量是独立的不会共享状态。对于每一种 F 和 T 的组合都会实例化一个独立版本的 useF 函数其静态变量 count 也是独立的。 std::function在头文件functional
// 类模板原型如下
template class T function; // undefined
template class Ret, class... Args
class functionRet(Args...);
模板参数说明
Ret: 被调用函数的返回类型
Args…被调用函数的形参他不是定义可调用对象而是包装可定义对象
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()
{// 函数名(函数指针)functionint(int, int) func1 f;cout func1(1, 2) endl;// 函数对象functionint(int, int) func2 Functor();cout func2(1, 2) endl;// lambda表达式functionint(int, int) func3 [](const int a, const int b){return a b; };cout func3(1, 2) endl;// 类的成员函数functionint(int, int) func4 Plus::plusi;cout func4(1, 2) endl;functiondouble(Plus, double, double) func5 Plus::plusd;cout func5(Plus(), 1.1, 2.2) endl;return 0;
}类成员函数与普通函数的区别
普通函数
int f(int a, int b)
{return a b;
}这是一个普通的全局函数。普通函数的调用是直接的f(1, 2)它不依赖于对象或者类的上下文。std::function 可以直接接受普通函数指针因此不需要加取地址符来指明是函数指针。
类的静态成员函数
class Plus
{
public:static int plusi(int a, int b){return a b;}double plusd(double a, double b){return a b;}
};plusi 是 静态成员函数属于类 Plus但它不依赖于对象实例。静态成员函数的调用方式和普通函数类似可以通过类名直接访问 Plus::plusi但也可以通过对象实例调用。静态成员函数的行为类似于普通的全局函数因此它可以作为一个普通函数来传递。
为什么静态成员函数要加取地址符 ?
在调用静态成员函数时我们通常需要通过类名来指明该函数是属于类的静态函数而不是实例成员函数。因此即使是静态成员函数它也需要通过取地址符 来指定其指针类型。
functionint(int, int) func4 Plus::plusi;这里Plus::plusi 是静态成员函数的指针告诉 std::function func4 要存储的是 plusi 函数的地址。虽然 plusi 是静态成员函数但它依然是一个函数并且它的签名是 int(int, int)和普通函数一样因此我们使用取地址符 来获取函数指针。
类的非静态成员函数
functiondouble(Plus, double, double) func5 Plus::plusd;plusd 是一个 非静态成员函数它依赖于类的实例来调用因为它需要访问类实例的成员数据如果有的话。非静态成员函数的调用需要通过对象实例来绑定obj.plusd(a, b)。为了将非静态成员函数作为函数指针传递必须先提供一个对象实例来进行绑定。
为什么非静态成员函数不能直接作为函数指针传递
非静态成员函数不是普通的全局函数它是绑定到类的实例上的。也就是说调用一个非静态成员函数需要一个类的实例因此它的地址实际上是包含了实例的上下文的。这种成员函数的指针通常被称为成员函数指针它和普通函数指针有很大的区别。
在 C 中非静态成员函数必须通过对象实例来调用。例如
Plus p;
p.plusd(1.1, 2.2); // 通过对象 p 来调用而在 std::function 中传递成员函数指针时需要额外提供一个对象实例或引用来绑定成员函数。可以通过如下方式来实现
functiondouble(Plus, double, double) func5 Plus::plusd;
cout func5(Plus(), 1.1, 2.2) endl;这里的 Plus() 是一个临时对象它被传递给 func5 作为对象实例从而调用 plusd 成员函数。
成员函数不能像普通函数一样直接作为指针传递它们是绑定到对象的因此不能直接传递函数指针。非静态成员函数需要通过对象实例来绑定因此我们在 std::function 中也需要传递一个对象实例来确保函数能够正确调用。
#include functional
templateclass 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::functiondouble(double) func1 f;cout useF(func1, 11.11) endl;// 函数对象std::functiondouble(double) func2 Functor();cout useF(func2, 11.11) endl;// lambda表达式std::functiondouble(double) func3 [](double d)-double { return d /4; };cout useF(func3, 11.11) endl;return 0;
}包装器解决了模版实例化多份的问题 题目链接逆波兰表达式 题目描述 第一种是没有包装器的做法遇见数字加进去遇见符号计算
class Solution {
public:int evalRPN(vectorstring tokens) {stackint 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(leftright);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 C11st.push(stoi(str));} }return st.top();}
};下面是用包装器
class Solution {
public:int evalRPN(vectorstring tokens) {stackint st;mapstring, functionint(int, int) 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 C11st.push(stoi(str));}}return st.top();}
};2.bind
std::bind 是 C11 引入的一个函数模板用于创建一个新的可调用对象通常是函数对象。这个函数对象“绑定”了原始函数的一些参数并返回一个新的函数可以通过新的参数进行调用。可以把它看作是部分应用partial application的一种实现。 std::bind 允许我们预先绑定一些参数使得我们可以方便地创建定制化的、部分应用的函数。
基本语法
std::bind(callable, arg1, arg2, ..., argN)callable可以是普通函数、函数对象、成员函数、或者 Lambda 表达式等。arg1, arg2, …, argN是你想要绑定的参数std::bind 会在新的函数调用时预先固定这些参数的值。
返回值
std::bind 返回一个可调用对象通常是函数对象该对象能够在稍后的时间接受剩余的参数并执行绑定函数。
常见用法示例
1. 绑定普通函数的参数
假设我们有一个普通函数 add它接受两个整数并返回它们的和
#include iostream
#include functional // 引入 std::bindint add(int a, int b) {return a b;
}int main() {// 绑定 add 函数第一个参数绑定为 10auto add10 std::bind(add, 10, std::placeholders::_1); // _1 表示占位符表示等待一个新的参数std::cout add10(5) std::endl; // 10 5 15return 0;
}输出
15在这个例子中std::bind 将 add 函数的第一个参数绑定为 10返回一个新的函数 add10它只需要一个参数来完成调用。std::placeholders::_1 是一个占位符表示 add10 需要一个新的参数来替代这个占位符。
2. 绑定成员函数
如果你想绑定一个类的成员函数需要传递一个对象实例来调用成员函数
#include iostream
#include functional // 引入 std::bindclass Calculator {
public:int add(int a, int b) {return a b;}
};int main() {Calculator calc;// 绑定成员函数 add必须提供对象实例auto bound_add std::bind(Calculator::add, calc, std::placeholders::_1, std::placeholders::_2);std::cout bound_add(3, 4) std::endl; // 3 4 7return 0;
}输出
7在这个例子中我们使用 std::bind 绑定了类的成员函数 add并指定了一个对象实例 calc。std::placeholders::_1 和 std::placeholders::_2 表示调用时提供的两个参数。
3. 绑定成员函数与对象实例
有时你需要绑定成员函数并且在绑定时固定对象实例而后续调用时只需要提供其他参数。你可以通过以下方法来完成
#include iostream
#include functional // 引入 std::bindclass Printer {
public:void print(const std::string str) {std::cout Printed: str std::endl;}
};int main() {Printer printer;// 绑定成员函数 print并固定对象实例auto bound_print std::bind(Printer::print, printer, std::placeholders::_1);bound_print(Hello, World!); // 输出: Printed: Hello, World!return 0;
}输出
Printed: Hello, World!在这个例子中std::bind 将 Printer::print 成员函数与对象 printer 绑定并返回一个新的函数 bound_print该函数只需传递一个字符串参数即可。
4. 使用多个占位符
std::bind 支持多个占位符。占位符的编号从 _1 开始用于指定参数的顺序。
#include iostream
#include functional // 引入 std::bindint multiply(int a, int b, int c) {return a * b * c;
}int main() {// 绑定前两个参数并保留最后一个参数auto bound_multiply std::bind(multiply, 2, 3, std::placeholders::_1);std::cout bound_multiply(4) std::endl; // 2 * 3 * 4 24return 0;
}输出
24在这个例子中我们将 multiply 的前两个参数绑定为 2 和 3使用占位符 _1 表示剩余的参数最后通过 bound_multiply(4) 提供第三个参数。
5. 绑定 Lambda 表达式
std::bind 不仅支持函数指针还可以绑定 Lambda 表达式
#include iostream
#include functional // 引入 std::bindint main() {// 绑定 Lambda 表达式固定第一个参数auto bound_lambda std::bind([](int a, int b) { return a b; }, 10, std::placeholders::_1);std::cout bound_lambda(5) std::endl; // 10 5 15return 0;
}输出
15std::bind 的核心功能将函数、成员函数或 Lambda 表达式与一些固定的参数绑定生成一个新的可调用对象后续调用时可以提供剩余的参数。std::placeholders::_N占位符用于指定绑定参数的位置_1 表示第一个占位符_2 表示第二个占位符的顺序决定了参数传递的顺序。用途 部分应用可以在调用函数时预先固定一些参数。适应某些 API 设计例如事件回调、适配器设计等需要将一部分参数绑定到函数中。结合算法使用在 STL 算法如 std::for_each中结合 std::bind 可以生成带有部分固定参数的自定义操作。
