南县建设局网站企业培训课程有哪些内容

当前位置： 首页 > news >正文

南县建设局网站,企业培训课程有哪些内容,建设网站一定需要云服务器么,企业培训系统app上篇#xff1a; 【C】– C11基础常用知识点#xff08;上#xff09;_川入的博客-CSDN博客 目录 新的类功能 默认成员函数 可变参数模板 可变参数 可变参数模板 empalce lambda表达式 C98中的一个例子 lambda表达式 lambda表达式语法 捕获列表 lambda表达底层 …上篇 【C】– C11基础常用知识点上_川入的博客-CSDN博客 目录 新的类功能 默认成员函数 可变参数模板 可变参数 可变参数模板 empalce lambda表达式 C98中的一个例子 lambda表达式 lambda表达式语法 捕获列表 lambda表达底层 包装器 function包装器 bind绑定 新的类功能 默认成员函数 原来C类中有6个默认成员函数 构造函数 析构函数 拷贝构造函数 拷贝赋值重载 取地址重载 const 取地址重载 最后重要的是前4个后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。 C11 新增了两个移动构造函数和移动赋值运算符重载。 所以到了C11后有8个默认成员函数。 移动构造函数和移动赋值运算符重载的又来以及原理【C】– C11 - 右值引用和移动语义上万字详细配图配代码从执行一步步讲解_川入的博客-CSDN博客 只有在深拷贝的情况下才会有移动构造函数和移动赋值运算符重载。可以认为 拷贝构造函数与拷贝赋值重载针对于左值的拷贝。移动构造函数和移动赋值重载针对于右值的拷贝。移动构造函数和移动赋值重载编译器自行生成的默认成员函数能用的条件的复杂度与苛刻程度远远大于构造函数、析构函数 、拷贝构造函数 、拷贝赋值重载4个默认成员函数。由于取地址重载 、const 取地址重载几乎不用自己写用编译器的即可所以忽略 针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下编译器生成默认移动构造函数的条件没有自己实现移动构造函数且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。 编译器生成默认移动构造函数的实现默认生成的移动构造函数对于内置类型成员会执行逐成员按字节拷贝。自定义类型成员则需要看这个成员是否实现移动构造如果实现了就调用移动构造没有实现就调用拷贝构造。 编译器生成默认移动赋值重载函数的条件你没有自己实现移动赋值重载函数且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个那么编译器会自动生成一个默认移动赋值。编译器生成默认移动赋值重载函数的实现默认生成的移动构造函数对于内置类型成员会执行逐成员按字节拷贝自定义类型成员则需要看这个成员是否实现移动赋 值如果实现了就调用移动赋值没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)。 如果你提供了移动构造或者移动赋值编译器不会自动提供拷贝构造和拷贝赋值。强制生成默认函数的关键字default           C11可以让我们更好的控制要使用的默认函数。假设你要使用某个默认的函数但是因为一些原因这个函数没有默认生成。比如我们提供了拷贝构造就不会生成移动构造了那么我们可以使用default关键字显示指定移动构造生成。 class Person { public:Person(const char *name , int age 0): _name(name), _age(age){}Person(const Person p): _name(p._name), _age(p._age){}Person(Person p) default;private:bit::string _name;int _age; };int main() {Person s1;Person s2 s1;Person s3 std::move(s1);return 0; } 禁止生成默认函数的关键字delete         如果能想要限制某些默认函数的生成在C98中是该函数设置成private并且只声明补丁已这样只要其他人想要调用就会报错。在C11中更简单只需在该函数声明加上delete即可该语法指示编译器不生成对应函数的默认版本称delete修饰的函数为删除函数。 class Person { public:Person(const char name , int age 0): _name(name), _age(age){}Person(const Person p) delete;private:bit::string _name;int age; }; int main() {Person s1;Person s2 s1;Person s3 std::move(s1);return 0; }         可以使用default关键字强行让编译器生成但是需要注意析构函数 、拷贝构造、拷贝赋值重载也会收到影响需要自己写或也强制生成。没有什么意义所以一般default关键字是用于构造因为拷贝构造也属于构造如果写了拷贝构造就不会默认生成构造了。 #问如何用delete关键字实现一个类只能再堆上创建对象 平时我们创建的类是可以在栈区、全局数据区上创建的。 class HeapOnly {};int main() {HeapOnly hp1; // 栈区static HeapOnly h2; // 全局数据区return 0; } 我们可以通过delete析构函数然后使用new开辟类。 class HeapOnly { public:// HeapOnly()// {// str new char[10];// }// void Destroy()// {// delete[] str_;// operator delete(this); // 内存管理之重载operator delete// }~HeapOnly() delete; private:char str; };int main() {// HeapOnly hp1; // 栈区 – 会调析构// static HeapOnly h2; // 全局数据区 – 会调析构// new出来的对象会调用构造 – 这个时候会导致资源泄漏HeapOnly *ptr new HeapOnly;operator delete(ptr);return 0; } new是c中的操作符malloc是c中的一个函数。new不止是分配内存而且会调用类的构造函数同理delete会调用类的析构函数malloc只会单纯的分配内存不会进行初始化类成员的工作同样free也不会调用析构函数。#问 class HeapOnly { public:HeapOnly(){str new char[10];}~HeapOnly() delete; private:char* str; };         对于构造函数是new空间因为不能调用析构而不能使用delete导致值空间泄漏怎么办 我们可以搞一个函数利用函数将其释放。 class HeapOnly { public:HeapOnly(){str new char[10];}void Destroy(){delete[] str;operator delete(this); // 内存管理之重载operator delete// 也可以使用free}~HeapOnly() delete; private:char* str; };int main() {// HeapOnly hp1; // 栈区 – 会调析构// static HeapOnly h2; // 全局数据区 – 会调析构// new出来的对象会调用构造 – 这个时候会导致资源泄漏HeapOnly ptr new HeapOnly;ptr-Destroy();return 0; } 继承的时候要小心因为指针是可能出现偏移的继承之后切片可能成员位置发生变化operator delete(this)的释放位置就可能不对。 可变参数模板 可变参数 可变参数最早的出现是在C语言 以printf不确定参数传多少个参数后面可以传一串值也就可变参数可以有0 ~ n个参数。底层是用数组实现的。 可变参数模板 下面就是一个基本可变参数的函数模板// Args是一个模板参数包args是一个函数形参参数包 // 声明一个参数包Args…args这个参数包中可以包含0到任意个模板参数。 template class …Args void ShowList(Args… args) {}// (不一定非要写作Args、args可以换一个名字只是这两个常用) #include string// 可变参数的函数模板 template class …Args void ShowList(Args… args) {}int main() {std::string str(hello);ShowList();ShowList(1);ShowList(1, A);ShowList(1, A, str);return 0; }         上面的参数args前面有省略号所以它就是一个可变模版参数我们把带省略号的参数称为“参数包”它里面包含了0到NN0个模版参数。我们无法直接获取参数包args中的每个参数的只能通过展开参数包的方式来获取参数包中的每个参数这是使用可变模版参数的一个主要特点也是最大的难点即如何展开可变模版参数。         如果我们想拿到参数包里面的参数是不好拿的sizeof可以帮助我们算参数包里面有多少个参数 #include string #include iostream// 可变参数的函数模板 template class …Args void ShowList(Args… args) {std::cout sizeof…(args) std::endl; }int main() {std::string str(hello);ShowList();ShowList(1);ShowList(1, A);ShowList(1, A, str);return 0; } Note for(int i 0; i sizeof…(args); i) {std::cout args[i] ; // errorargs[i]不支持 }         语法不支持使用args[i]这样方式获取可变参数所以我们需要用一些奇招来 一一 获取参数包的值。 第一种递归函数方式展开参数包         将参数包改一改增加一个参数。 #include iostream #include string// 递归终止函数 template class T void ShowList() {std::cout std::endl; }// 展开函数 template class T, class… Args void ShowList(const T value, Args… args) // 第一个参数传给value剩下的传给参数包args。 {cout value ;ShowList(args…); // 参数超过0个递归调自己参数0个调递归终止函数。 }int main() {ShowList(1);ShowList(1, A);ShowList(1, A, std::string(sort));return 0; }利用递归不断地推出参数包中的内容。 第二种逗号表达式展开参数包         这种展开参数包的方式不需要通过递归终止函数是直接在ShowList函数体中展开的, PrintArg不是一个递归终止函数只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式因为逗号表达式会按顺序执行逗号前面的表达式。 #include iostream #include string template class T void PrintArg(cosnt T t) {std::cout t ; }// 展开函数 template class… Args void ShowList(Args… args) {// 利用逗号表达式去初始化arrarr编译的时候就会知道要开多大这个时候就会依次展开args参数包。// 利用逗号表达式去取右边的值0。(逗号表达式会按顺序执行逗号前面的表达式)int arr[] {(PrintArg(args), 0)…};std::cout std::endl; }int main() {ShowList(1);ShowList(1, A);ShowList(1, A, std::string(sort));return 0; } 同理也可以优化为不适用逗号表达式展开参数包 #include iostream #include string template class T int PrintArg(cosnt T t) {std::cout t ;return 0; }// 展开函数 template class… Args void ShowList(Args… args) {// arr编译的时候就会知道要开多大这个时候就会依次展开args参数包。int arr[] { PrintArg(args)… };std::cout std::endl; }int main() {ShowList(1);ShowList(1, A);ShowList(1, A, std::string(sort));return 0; } empalce         分析STL容器中的empalce相关接口函数 https://cplusplus.com/reference/vector/vector/emplace/ https://cplusplus.com/reference/vector/vector/emplace_back/https://cplusplus.com/reference/list/list/emplace_back/以vector容器的emplace_back为例emplace_back是在一个函数模板里面把一个成员函数是实现成可变参数包。其就是通过将可变参数包不断不断的往下传传到最下面去初始化对应数据或者是链表的话就初始化节点里的数据。 template class… Args void emplace_back (Args… args); 首先我们看到的emplace系列的接口支持模板的可变参数并且万能引用/引用折叠即可以引用左值也可以引用右值。#问那么相对insert和emplace系列接口的优势到底在哪里呢 // vector::emplace_back #include iostream #include vectorint main () {std::vectorint myvector;myvector.push_back(100);myvector.emplace_back(200);return 0; } 如果只是简单的int的其与push_back就没有什么区别。主要的区别在于// vector::emplace_back #include iostream #include vector #include string #include utilityint main() {std::vectorstd::pairstd::string, int myvector;myvector.push_back(std::make_pair(sort, 1));myvector.emplace_back(std::make_pair(sort, 1));myvector.emplace_back(sort, 1);return 0; }        效率上就emplace_back更好因为make_pair是先构造构造了一个pair。如此push_back就传了一个pair对象。所以调push_back是 左值构造 拷贝构造。右值构造 移动构造。        emplace_back是不用着急创建pair对象我们可将这个参数包一直向下传递直到最后需要插入数据的时候直接用这个数据包创建pair对象。 直接构造。        所以emplace系列比insert系列接口不一定高效。 通过代码凸显区别         不一定所有容器都会出现于源码的实现有关系此处使用list容器并在VS2019实现出来的 #include iostream #include list #include stringclass Date { public:Date(int year 1, int month 1, int day 1):_year(year), _month(month), _day(day){std::cout Date(int year 1, int month 1, int day 1) std::endl;}Date(const Date d):_year(d._year), _month(d._month), _day(d._day){std::cout Date(const Date d) std::endl;}private:int _year;int _month;int _day; };int main() {std::listDate lt1;lt1.push_back(Date(2022, 11, 16));std::cout ——————————— std::endl;lt1.emplace_back(2022, 11, 16);return 0; }         所以建议这个这种场景下直接使用emplace系列接口。 lambda表达式         lambda也叫做匿名函数。 像函数使用的对象 / 类型 函数指针 – C不喜欢的操作所以有了仿函数。全局的函数仿函数 / 函数对象。全局的类lambda。局部 C98中的一个例子 因为由于仿函数有诸多的不便。如果待排序元素为自定义类型需要用户定义排序时的比较规则对于以下的三个成员一个就要创建2个less、greater就是6个。 #include stringstruct Goods {std::string _name; // 名字double _price; // 价格int _evaluate; // 评价Goods(const char str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){} }; 随着C语法的发展人们开始觉得上面的写法太复杂了每次为了实现一个algorithm算法都要重新去写一个类如果每次比较的逻辑不一样还要去实现多个类特别是相同类的命名这些都给编程者带来了极大的不便。因此在C11语法中出现了Lambda表达式。 lambda表达式 lambda表达式语法 lambda表达式书写格式capture-list mutable - return-type { statement } 1. lambda表达式各部分说明 [capture-list]  捕捉列表。该列表总是出现在lambda函数的开始位置编译器根据[]来判断接下来的代码是否为lambda函数捕捉列表能够捕捉上下文中的变量供lambda函数使用。 (parameters)参数列表。与普通函数的参数列表一致如果不需要参数传递则可以连同()一起省略无参时可以省略mutable默认情况下lambda函数总是一个const函数mutable可以取消其常量性。使用该修饰符时参数列表不可省略(即使参数为空)。 -returntype返回值类型。用追踪返回类型形式声明函数的返回值类型没有返回值时此部分可省略。返回值类型明确情况下也可省略由编译器对返回类型进行推导。 {statement}函数体。在该函数体内除了可以使用其参数外还可以使用所有捕获到的变量。 注意         在lambda函数定义中参数列表和返回值类型都是可选部分而捕捉列表和函数体可以为空。因此C11中最简单的lambda函数为[]{}; 该lambda函数不能做任何事情。 #include iostreamint main() {// 两个数相加的lambda// 没有函数名加一个捕捉列表[]而已。因为没有名字所以调用不好调// 但是 - int{ return a b; }整体是一个对象所以就可以巧用auto。auto add1 - int{ return a b; };std::cout add1(1, 2) std::endl;// 省略返回值auto add2 { return a b; };std::cout add2(1, 2) std::endl; }         于是对于前面的三个成员一个就要创建2个less、greater就是6个。解决 #include string #include vector #include algorithmstruct Goods {std::string _name; // 名字double _price; // 价格int _evaluate; // 评价//…Goods(const char *str, double price, int evaluate): _name(str), _price(price), _evaluate(evaluate){} };int main() {std::vectorGoods v {{苹果, 2.1, 5}, {香蕉, 3, 4}, {橙子, 2.2, 3}, {菠萝, 1.5, 4}};sort(v.begin(), v.end(), { return g1._name g2._name; });sort(v.begin(), v.end(), { return g1._name g2._name; });sort(v.begin(), v.end(), { return g1._price g2._price; });sort(v.begin(), v.end(), { return g1._price g2._price; });sort(v.begin(), v.end(), { return g1._evaluate g2._evaluate; });sort(v.begin(), v.end(), { return g1._evaluate g2._evaluate; }); } #问如何写一个交换swap函数         可以像上面那样写但是会非常的难看。 #include iostreamint main() {// 交换变量的lambda - 行数会多int x 0, y 1;auto swap1 - void{int tmp x1; x1 x2; x2 tmp; };swap1(x, y);std::cout x : y std::endl; }         我们可以这样写 #include iostreamint main() {// 交换变量的lambda - 行数会多int x 0, y 1;auto swap1 - void{int tmp x1; x1 x2; x2 tmp; };swap1(x, y);std::cout x : y std::endl; } 捕获列表 #问假如我们想不传参数交换xy呢 利用捕捉列表实现注意 想捕捉谁就写谁只能捕捉跟lambda表达式同一个作用域的对象。默认捕捉过来的变量不能修改 —— 加mutable让捕捉过来的变量可以修改使用mutable必须加()。默认捕捉是拷贝的方式捕捉严格意义上说是传值捕捉。lambda还是一个函数调用是有栈帧的 —— 可以理解为改变形参不会改变实参 #include iostreamint main() {// 交换变量的lambda - 行数会多int x 0, y 1;// 可以理解为改变形参不会改变实参auto swap x, ymutable{int tmp x; x y; y tmp; };swap();std::cout x : y std::endl; } 所以mutable在实际中不起价值作用。 捕获列表说明 捕捉列表描述了上下文中那些数据可以被lambda使用以及使用的方式传值还是传引用。 [var]表示值传递方式捕捉变量var。[]表示值传递方式捕获所有父作用域中的变量(包括this)。[var]表示引用传递捕捉变量var。[]表示引用传递捕捉所有父作用域中的变量(包括this)。[this]表示值传递方式捕捉当前的this指针。 注意
父作用域指包含lambda函数的语句块 语法上捕捉列表可由多个捕捉项组成并以逗号分割。 比如 [, a, b]以引用传递的方式捕捉变量a和b值传递方式捕捉其他所有变量。[, a, this]值传递方式捕捉变量a和this引用方式捕捉其他变量。捕捉列表不允许变量重复传递否则就会导致编译错误。 比如[, a]已经以值传递方式捕捉了所有变量捕捉a重复 在块作用域以外的lambda函数捕捉列表必须为空。 在块作用域中的lambda函数仅能捕捉父作用域中局部变量捕捉任何非此作用域或者非局部变量都会导致编译报错。 lambda表达式之间不能相互赋值即使看起来类型相同 #include iostreamvoid (*PF)();int main() {auto f1 []{ std::cout hello world std::endl; };auto f2 []{ std::cout hello world std::endl; };// f1 f2;   // 编译失败—提示找不到operator()// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();// 可以将lambda表达式赋值给相同类型的函数指针PF f2;PF();return 0; } lambda表达底层 函数对象又称为仿函数即可以想函数一样使用的对象就是在类中重载了operator()运算符的类对象与范围for很像。 范围for         并没有看起来这么的智能实际上是底层运用迭代器实现的。 class Rate { public:Rate(double rate) : _rate(rate){}double operator()(double money, int year){return money * _rate * year;}private:double _rate; };int main() {// 函数对象double rate 0.49;Rate r1(rate);r1(10000, 2);// lamberauto r2 - double{return monty * rate * year;};r2(10000, 2);return 0; } 仿函数的名称就是lambda_uuid。所以lambda表达式对于我们是匿名的对于编译器而言是有名的。实际在底层编译器对于lambda表达式的处理方式完全就是按照函数对象的方式处理的即如果定义了一个lambda表达式编译器会自动生成一个类在该类中重载了operator()。
包装器 function包装器 function包装器也叫作适配器C中的function本质是一个类模板也是一个包装器。 #include iostreamtemplate 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::cout useF(f, 11.11) std::endl;// 仿函数对象std::cout useF(Functor(), 11.11) std::endl;// lamber表达式对象std::cout useF(-double{ return d/4; }, 11.11) std::endl;return 0; }         因为上述的 f 的类型不同于是会被实例化成三个。         包装器可以很好的解决上面的问题将其变为1份。 std::function在头文件functional // 类模板原型如下 template class T function;     // undefined template class Ret, class… Args class functionRet(Args…); 模板参数说明 Ret: 被调用函数的返回类型 Args…被调用函数的形参 使用方法 // 使用方法如下 #include functional #include iostreamint f(int a, int b) {return a b; }struct Functor { public:int operator()(int a, int b){return a b;} };int main() {// 函数名(函数指针)std::functionint(int, int) func1 f;std::cout func1(1, 2) std::endl;// 函数对象std::functionint(int, int) func2 Functor();std::cout func2(1, 2) std::endl;// lamber表达式std::functionint(int, int) func3 { return a b; };std::cout func3(1, 2) std::endl;return 0; }         对于静态成员函数与非静态成员函数的不同 //使用方法如下 #include functional #include iostreamclass Plus { public:static int plusi(int a, int b){return a b;}double plusd(double a, double b){return a b;} };int main() {//类的成员函数 – 语法规定// 静态成员函数可以不用加可以加。并且可以直接调用。std::functionint(int, int) func4 Plus::plusi; std::cout func4(1, 2) std::endl;// 非静态成员函数需要加并且不能直接调用需要传对象此处为Plus。成员函数多传一个std::functiondouble(Plus, double, double) func5 Plus::plusd; std::cout func5(Plus(), 1.1, 2.2) std::endl;return 0; }         如果对于非静态成员函数不想多传一个类对象的参数可以通过绑定的方式解决这个问题。         所以对于上面的因为上述的 f 的类型不同于是会被实例化成三个就可以解决了 #include iostream #include functionaltemplate class F, class T T useF(F f, T x) {static int count 0;std::cout count: count std::endl;std::cout count: count std::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) f1 f;std::cout useF(f1, 11.11) std::endl;// 函数对象std::functiondouble(double) f2 Functor();std::cout useF(f2, 11.11) std::endl;// lamber表达式对象std::functiondouble(double) f3 -double{ return d / 4; };std::cout useF(f3, 11.11) std::endl;return 0; } 包装器的其他一些场景   class Solution { public:int evalRPN(vectorstring tokens){stacklong long st;mapstring, functionlong long(long long, long long) opFuncMap {{, { return i j; }},{-, { return i - j; }},{*, { return i * j; }},{/, { return i / j; }}};for (auto str : tokens){if (opFuncMap.find(str) ! opFuncMap.end()){long long right st.top();st.pop();long long left st.top();st.pop();st.push(opFuncMapstr);}else{// 1、atoi itoa// 2、sprintf scanf// 3、stoi to_string C11st.push(stoll(str));}}return st.top();} }; bind绑定 std::bind函数定义在头文件中是一个函数模板它就像一个函数包装器(适配器)接受一个可调用对象callable object生成一个新的可调用对象来“适应”原对象的参数列表。一般而言我们用它可以把一个原本接收N个参数的函数fn通过绑定一些参数返回一个接收M个M可以大于N但这么做没什么意义参数的新函数。同时使用std::bind函数还可以实现参数顺序调整等操作。 // 原型如下 template class Fn, class… Args /* unspecified / bind (Fn fn, Args… args);// with return type (2) template class Ret, class Fn, class… Args / unspecified */ bind (Fn fn, Args… args); 调用bind的一般形式auto newCallable bind(callable,arg_list); 库中就是使用了placeholders来占位 https://legacy.cplusplus.com/reference/functional/placeholders/ 其中的_1、_2、_3等就是用来占位的。_1代表第1个参数_2代表第2个参数……。调整的是形参的顺序。 #include functional #include iostreamint Div(int a, int b) {return a / b; }int main() {int x 10, y 2;std::cout Div(x, y) std::endl;// 调整顺序 – 鸡肋一般用不上// _1, _2…. 定义在placeholders命名空间中代表绑定函数对象的形参// _1_2… 分别代表第一个形参、第二个形参…//std::functionint(int, int) bindFunc bind(Div, std::placeholders::_2, std::placeholders::_1);auto bindFunc bind(Div, std::placeholders::_2, std::placeholders::_1);// 传时候不会变std::cout bindFunc(x, y) std::endl;return 0; } 可以理解为 // x - _1 -a // y - _2 -b。 auto bindFunc  bind(Div, _1, _2); bindFunc(x, y);// x - _2 -b // y - _1 -a。 auto bindFunc  bind(Div, _2, _1); bindFunc(x, y); 可以用绑定解决前面的非静态成员函数需要传类对象成员函数多传一个以绑定参数解决 - 调整个数。 #include functional #include iostream #include mapint Plus(int a, int b) {return a b; }int Mul(int a, int b, double rate) {return a * b * rate; }class Sub { public:int sub(int a, int b){return a - b;} };// 11:50继续 int main() {// 调整个数, 绑定死固定参数std::functionint(int, int) funcPlus Plus;// 本来要传3个.// functionint(Sub, int, int) funcSub Sub::sub;// 将其变为只传2个将1个此处Sub()固定在这个地方绑死 — 不能变。std::functionint(int, int) funcSub std::bind(Sub::sub, Sub(), std::placeholders::_1, std::placeholders::_2);// 1.5就固定死了std::functionint(int, int) funcMul std::bind(Mul, std::placeholders::_1, std::placeholders::_2, 1.5);std::mapstd::string, std::functionint(int, int) opFuncMap {{ , Plus},{ -, std::bind(Sub::sub, Sub(), std::placeholders::_1, std::placeholders::_2)}};std::cout funcPlus(1, 2) std::endl;std::cout funcMul(2, 2) std::endl;std::cout funcSub(1, 2) std::endl;std::cout opFuncMap std::endl;std::cout opFuncMap- std::endl;return 0; }