destoon 手机网站模板,怎么做网页新闻,中国网页设计师,泉港区规划建设局网站1.新的类功能
1.1默认的移动构造和移动赋值
原来C类中#xff0c;有6个默认成员函数#xff1a;构造函数/析构函数/拷⻉构造函数/拷⻉赋值重载/取地址重 载/const 取地址重载#xff0c;最后重要的是前4个#xff0c;后两个⽤处不⼤#xff0c;默认成员函数就是我们不写…1.新的类功能
1.1默认的移动构造和移动赋值
原来C类中有6个默认成员函数构造函数/析构函数/拷⻉构造函数/拷⻉赋值重载/取地址重 载/const 取地址重载最后重要的是前4个后两个⽤处不⼤默认成员函数就是我们不写编译器 会⽣成⼀个默认的。C11 新增了两个默认成员函数移动构造函数和移动赋值运算符重载。
如果你没有⾃⼰实现移动构造函数且没有实现析构函数 、拷⻉构造、拷⻉赋值重载中的任意⼀ 个。那么编译器会⾃动⽣成⼀个默认移动构造。默认⽣成的移动构造函数对于内置类型成员会执 ⾏逐成员按字节拷⻉⾃定义类型成员则需要看这个成员是否实现移动构造如果实现了就调⽤ 移动构造没有实现就调⽤拷⻉构造。
如果你没有⾃⼰实现移动赋值重载函数且没有实现析构函数 、拷⻉构造、拷⻉赋值重载中的任意 ⼀个那么编译器会⾃动⽣成⼀个默认移动赋值。默认⽣成的移动构造函数对于内置类型成员会 执⾏逐成员按字节拷⻉⾃定义类型成员则需要看这个成员是否实现移动赋值如果实现了就调⽤移动赋值没有实现就调⽤拷⻉赋值。(默认移动赋值跟上⾯移动构造完全类似)
如果你提供了移动构造或者移动赋值编译器不会⾃动提供拷⻉构造和拷⻉赋值。 1.2defult和delete
C11可以让你更好的控制要使⽤的默认函数。假设你要使⽤某个默认的函数但是因为⼀些原因 这个函数没有默认⽣成。⽐如我们提供了拷⻉构造就不会⽣成移动构造了那么我们可以使⽤ default关键字显⽰指定移动构造⽣成。
如果能想要限制某些默认函数的⽣成在C98中是该函数设置成private并且只声明补丁已 这样只要其他⼈想要调⽤就会报错。在C11中更简单只需在该函数声明加上delete即可该语法指⽰编译器不⽣成对应函数的默认版本称delete修饰的函数为删除函数。 2.STL中⼀些变化
下图1圈起来的就是STL中的新容器但是实际最有⽤的是unordered_map和unordered_set。这 两个我们前⾯已经进⾏了⾮常详细的讲解其他的⼤家了解⼀下即可。
STL中容器的新接⼝也不少最重要的就是右值引⽤和移动语义相关的push/insert/emplace系列接⼝和移动构造和移动赋值还有initializer_list版本的构造等这些前⾯都讲过了还有⼀些⽆关痛痒的如cbegin/cend等需要时查查⽂档即可。
容器的范围for遍历这个在容器部分也讲过了。 3.lambda
3.1lambda表达式语法
lambda 表达式本质是⼀个匿名函数对象跟普通函数不同的是他可以定义在函数内部。 lambda 表达式语法使⽤层⽽⾔没有类型所以我们⼀般是⽤auto或者模板参数定义的对象去接 收 lambda 对象。
lambda表达式的格式 [capture-list] (parameters)- return type { function boby }
[capture-list] : 捕捉列表该列表总是出现在 lambda 函数的开始位置编译器根据[]来 判断接下来的代码是否为 lambda 函数捕捉列表能够捕捉上下⽂中的变量供 lambda 函数使 ⽤捕捉列表可以传值和传引⽤捕捉具体细节3.2中我们再细讲。捕捉列表为空也不能省略。
(parameters) 参数列表与普通函数的参数列表功能类似如果不需要参数传递则可以连 同()⼀起省略
-return type 返回值类型⽤追踪返回类型形式声明函数的返回值类型没有返回值时此 部分可省略。⼀般返回值类型明确情况下也可省略由编译器对返回类型进⾏推导。
{function boby} 函数体函数体内的实现跟普通函数完全类似在该函数体内除了可以 使⽤其参数外还可以使⽤所有捕获到的变量函数体为空也不能省略。
int main()
{// ⼀个简单的lambda表达式auto add1 [](int x, int y)-int {return x y; };cout add1(1, 2) endl;// 1、捕捉为空也不能省略// 2、参数为空可以省略// 3、返回值可以省略可以通过返回对象⾃动推导// 4、函数体不能省略auto func1 []{cout hello xc endl;return 0;};func1();int a 0, b 1;auto swap1 [](int x, int y){int tmp x;x y;y tmp;};swap1(a, b);cout a : b endl;return 0;
}
运行结果 3.2捕捉列表
lambda 表达式中默认只能⽤ lambda 函数体和参数中的变量如果想⽤外层作⽤域中的变量就 需要进⾏捕捉
第⼀种捕捉⽅式是在捕捉列表中显⽰的传值捕捉和传引⽤捕捉捕捉的多个变量⽤逗号分割。[x y z] 表⽰x和y值捕捉z引⽤捕捉。
第⼆种捕捉⽅式是在捕捉列表中隐式捕捉我们在捕捉列表写⼀个表⽰隐式值捕捉在捕捉列表 写⼀个表⽰隐式引⽤捕捉这样我们 lambda 表达式中⽤了那些变量编译器就会⾃动捕捉那些 变量。 第三种捕捉⽅式是在捕捉列表中混合使⽤隐式捕捉和显⽰捕捉。[, x]表⽰其他变量隐式值捕捉 x引⽤捕捉[, x, y]表⽰其他变量引⽤捕捉x和y值捕捉。当使⽤混合捕捉时第⼀个元素必须是 或并且混合捕捉时后⾯的捕捉变量必须是值捕捉同理混合捕捉时后⾯的捕捉变量必 须是引⽤捕捉。 lambda 表达式如果在函数局部域中他可以捕捉 lambda 位置之前定义的变量不能捕捉静态 局部变量和全局变量静态局部变量和全局变量也不需要捕捉 lambda 表达式中可以直接使⽤。这也意味着 lambda 表达式如果定义在全局位置捕捉列表必须为空。 默认情况下 lambda 捕捉列表是被const修饰的也就是说传值捕捉的过来的对象不能修改 mutable加在参数列表的后⾯可以取消其常量性也就说使⽤该修饰符后传值捕捉的对象就可以 修改了但是修改还是形参对象不会影响实参。使⽤该修饰符后参数列表不可省略(即使参数为 空)。 相关代码如下
int y 0;
// 捕捉列表必须为空因为全局变量不⽤捕捉就可以⽤没有可被捕捉的变量
auto func2 []()
{y;
};
int main()
{// 只能用当前lambda局部域和捕捉的对象和全局对象int a 0, b 1, c 2, d 3;auto func1 [a, b](int x)mutable{// 值捕捉的变量不能修改引用捕捉的变量可以修改a;b;int ret a b x y;return ret;};//cout func1(1) endl;//func2();// 隐式值捕捉// 用了哪些变量就捕捉哪些变量auto func2 []{int ret a b c;return ret;};//cout func2() endl;// 隐式引用捕捉// 用了哪些变量就捕捉哪些变量auto func3 []{a;c;d;};//func3();//cout a b c d endl;// 混合捕捉1(a和b值捕捉)auto func4 [,a,b]{//a;//b;c;d;return a b c d;};//func4();//cout a b c d endl;// 混合捕捉2(a和b引用捕捉)auto func5 [, a, b]{a;b;//c;//d;return a b c d;};func5();cout a b c d endl;// 传值捕捉本质是⼀种拷⻉,并且被const修饰了// mutable相当于去掉const属性可以修改了// 但是修改了不会影响外⾯被捕捉的值因为是⼀种拷⻉auto func7 []()mutable{a;b;c;d;return a b c d;};//cout func7() endl;//cout a b c d endl;return 0;
}
3.3lambda的应用
在学习 lambda 表达式之前我们的使⽤的可调⽤对象只有函数指针和仿函数对象函数指针的 类型定义起来⽐较⿇烦仿函数要定义⼀个类相对会⽐较⿇烦。使⽤ lambda 去定义可调⽤对 象既简单⼜⽅便。
lambda 在很多其他地⽅⽤起来也很好⽤。⽐如线程中定义线程的执⾏函数逻辑智能指针中定 制删除器等 lambda 的应⽤还是很⼴泛的以后我们会不断接触到
#includealgorithm
struct Goods
{string _name; //名字double _price; //价格int _evaluate; //评价//...Goods(const char* str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){}
};
struct Compare1
{bool operator()(const Goods g1, const Goods gr){return g1._price gr._price;}
};
struct Compare2
{bool operator()(const Goods g1, const Goods gr){return g1._price gr._price;}
};
int main()
{vectorGoods v { { 苹果, 2.1, 5 }, { 香蕉, 3, 4 }, { 橙子, 2.2, 3}, { 菠萝, 1.5, 4 } };// 类似这样的场景我们实现仿函数对象或者函数指针支持商品中// 不同项的比较相对还是比较麻烦的那么这里lambda就很好用了// 价格升序//sort(v.begin(), v.end(), Compare1());// 价格降序//sort(v.begin(), v.end(), Compare2());sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._price g2._price; });sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._price g2._price; });sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._evaluate g2._evaluate; });sort(v.begin(), v.end(), [](const Goods g1, const Goods g2) {return g1._evaluate g2._evaluate; });return 0;
}3.4 lambda的原理
lambda 的原理和范围for很像编译后从汇编指令层的⻆度看压根就没有 lambda 和范围for 这样的东西。范围for底层是迭代器⽽lambda底层是仿函数对象也就说我们写了⼀个 lambda 以后编译器会⽣成⼀个对应的仿函数的类。
仿函数的类名是编译按⼀定规则⽣成的保证不同的 lambda ⽣成的类名不同lambda参数/返 回类型/函数体就是仿函数operator()的参数/返回类型/函数体 lambda 的捕捉列表本质是⽣成 的仿函数类的成员变量也就是说捕捉列表的变量都是 lambda 类构造函数的实参当然隐式捕 捉编译器要看使⽤哪些就传那些对象。
上⾯的原理我们可以透过汇编层了解⼀下下⾯第⼆段汇编层代码印证了上⾯的原理。
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;//lambdaauto r2 [rate](double money, int year) {return money * rate * year;};// 捕捉列表的rate可以看到作为lambda_1类构造函数的参数传递了这样要拿去初始化成员变量//函数对象Rate r1(rate);r1(10000, 2);r2(10000, 2);auto func1 [] {cout hello world endl;};func1();return 0;
} 4. 包装器
4.1 function
template class T
class function; // undefined
template class Ret, class... Args
class functionRet(Args...);std::function 是⼀个类模板也是⼀个包装器。 std::function 的实例对象可以包装存 储其他的可以调⽤对象包括函数指针、仿函数、 lambda 、 bind 表达式等存储的可调⽤对 象被称为 std::function 的⽬标。若 std::function 不含⽬标则称它为空。调⽤空 std::function 的⽬标导致抛出 std::bad_function_call异常。
以上是 function 的原型他被定义头⽂件中。std::function - cppreference.com 是function的官⽅⽂件链接。
函数指针、仿函数、 lambda 等可调⽤对象的类型各不相同 std::function 的优势就是统 ⼀类型对他们都可以进⾏包装这样在很多地⽅就⽅便声明可调⽤对象的类型下⾯的第⼆个代 码样例展⽰了 std::function 作为map的参数实现字符串和可调⽤对象的映射表功能。
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 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()
{// 包装各种可调用对象functionint(int, int)f1 f;functionint(int, int)f2 Functor();functionint(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; // 包装静态成员函数// 成员函数要指定类域并且前面加才能获取地址//静态前面可加可不加(),建议加上functionint(int, int) f4 Plus::plusi;cout f4(1, 1) endl;functiondouble(Plus*, double, double) f5 Plus::plusd;Plus pl;cout f5(pl, 1.111, 1.1) endl;functiondouble(Plus, double, double) f6 Plus::plusd;cout f6(pl, 1.1, 1.1) endl;cout f6(Plus(), 1.1, 1.1) endl;//匿名对象functiondouble(Plus, double, double) f7 Plus::plusd;cout f7(move(pl), 1.1, 1.1) endl;cout f7(Plus(), 1.1, 1.1) 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(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();}
};使⽤map映射string和function的⽅式实现 这种⽅式的最⼤优势之⼀是⽅便扩展假设还有其他运算我们增加map中的映射即可
class Solution {
public:int evalRPN(vectorstring tokens) {stackint st;// function作为map的映射可调⽤对象的类型mapstring ,functionint(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();}
};4.2 bind
simple(1)
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 是⼀个函数模板它也是⼀个可调⽤对象的包装器可以把他看做⼀个函数适配器对接收 的fn可调⽤对象进⾏处理后返回⼀个可调⽤对象。 bind 可以⽤来调整参数个数和参数顺序。 bind 也在这个头⽂件中。
调⽤bind的⼀般形式 auto newCallable bind(callable,arg_list); 其中 newCallable本⾝是⼀个可调⽤对象arg_list是⼀个逗号分隔的参数列表对应给定的callable的 参数。当我们调⽤newCallable时newCallable会调⽤callable并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字其中n是⼀个整数这些参数是占位符表⽰ newCallable的参数它们占据了传递给newCallable的参数的位置。数值n表⽰⽣成的可调⽤对象 中参数的位置_1为newCallable的第⼀个参数_2为第⼆个参数以此类推。_1/_2/_3....这些占 位符放到placeholders的⼀个命名空间中。 相关代码如下
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: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()
{bind 本质返回的⼀个仿函数对象调整参数顺序不常⽤_1代表第⼀个实参_2代表第⼆个实参//auto sub1 bind(Sub, _1, _2);//cout sub1(10, 5) endl;//auto sub2 bind(Sub, _2, _1);//cout sub2(10, 5) endl;调整参数个数 常用//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;// 成员函数对象进行绑死就不需要每次都传递了//functiondouble(Plus, double, double) f8 Plus::plusd;//Plus pd;//cout f8(move(pd), 1.1, 1.1) endl;//cout f8(Plus(), 1.1, 1.1) endl;//functiondouble(double, double) f9 bind(Plus::plusd, Plus(), _1, _2);//cout f9(1.1, 1.1) endl;// 计算复利的lambda// 复利前一年的利息变成第二年本金// (10000*0.02 10000)*0.02 10000*0.02 10000// 利率 本金 年限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;//减去本金};cout func1(0.05, 10000000, 30) endl;// 绑死一些参数实现出支持不同年华利率不同金额和不同年份计算出复利的结算利息functiondouble(double) func3_1_5 bind(func1, 0.015, _1, 3);functiondouble(double) func5_1_5 bind(func1, 0.015, _1, 5);functiondouble(double) func10_1_5 bind(func1, 0.015, _1, 10);functiondouble(double) func3_2_5 bind(func1, 0.025, _1, 3);functiondouble(double) func5_2_5 bind(func1, 0.025, _1, 5);functiondouble(double) func10_2_5 bind(func1, 0.025, _1, 10);cout func3_1_5(1000000) endl;cout func5_1_5(1000000) endl;cout func10_1_5(1000000) endl;cout func3_2_5(1000000) endl;cout func5_2_5(1000000) endl;cout func10_2_5(1000000) endl;return 0;
}
