python入门之基础语法,英语基础语法大全
墨初 知识笔记 114阅读
目录
1. 统一的列表初始化
①{}进行初始化
②std::initializer_list
1.类型
2.使用场景
2.声明
①auto
②decltype
③nullptr
3.范围for
4.右值引用与移动语义
①左值引用与右值引用
②左值引用与右值引用的比较
③左值引用与右值引用的使用场景与意义、移动语义
④右值引用引用左值及其一些更深入的使用场景分析
⑤完美转发
1.模板中的&&、万能引用
2.std::forward 完美转发在传参的过程中保留对象原生类型属性
3.完美转发实际中的使用场景
5.STL的变化
①新容器
②容器中的一些新接口
1.迭代器接口
2.所有容器均支持了{}列表初始化的构造函数
3.所有容器均新增了emplace系列
4.容器新增了移动构造与移动赋值
6.类的变化
①默认成员函数
②类成员变量初始化
③强制生成默认函数的关键字default
④禁止生成默认函数的关键字delete
⑤继承和多态中的final与override关键字
7.可变参数模板
①使用递归函数方式展开参数包
②使用逗号表达式展开参数包
③STL中的emplace接口
8.lambda表达式
①C98中的一种情况
②lambda表达式
③lambda表达式语法
④函数对象与lambda表达式
9.包装器
①function包装器
②bind
1. 统一的列表初始化 ①{}进行初始化
在C98标准中允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。即
struct Point{int _x;int _y;};int main(){int array1[] { 1, 2, 3, 4, 5 };int array2[5] { 0 };Point p { 1, 2 };return 0;}而在C11中大括号括起的列表(初始化列表)的使用范围被扩大了使其可用于所有的内置类型和用户自定义的类型使用初始化列表时可添加等号()也可不添加。如
struct Point{Point(int x, int y):_x(x),_y(y){cout << Point(int x, int y) << endl;}int _x;int _y;};int main(){int x 1;int y { 2 };int z{ 3 };int a1[] { 1,2,3 };int a2[] { 1,2,3 };// 本质都是调用构造函数Point p0(0, 0);Point p1 { 1,1 }; // 多参数构造函数隐式类型转换Point p2{ 2,2 };const Point& r { 3,3 };int* ptr1 new int[3]{ 1,2,3 };Point* ptr2 new Point[2]{p0,p1};Point* ptr3 new Point[2]{ {0,0},{1,1} };return 0;}注建议在日常定义中不要去掉虽然不要求会用但是要能看懂
②std::initializer_list 1.类型在这里我们可以使用typeid来查看一个变量的类型即
int main(){// the type of il is an initializer_list auto il { 10, 20, 30 };cout << typeid(il).name() << endl;return 0;}运行有
2.使用场景std::initializer_list一般是作为构造函数的参数C11对STL中的不少容器就增加了std::initializer_list作为参数的构造函数这样初始化容器对象就更方便了。
让我们查看几个STL的文档
也可以作为operator的参数这样就可以用大括号赋值
举几个例子
int main(){vector<int> v { 1,2,3,4 };list<int> lt { 1,2 };// 这里{sort, 排序}会先初始化构造一个pair对象map<string, string> dict { {sort, 排序}, {insert, 插入} };// 使用大括号对容器赋值v { 10, 20, 30 };return 0;}C11提供了多种简化声明的方式尤其是在使用模板时。
①auto在C98中auto是一个存储类型的说明符表明变量是局部自动存储类型但是局部域中定义局部的变量默认就是自动存储类型所以auto就没什么价值了。C11中废弃auto原来的用法将其用于实现自动类型推断。这样要求必须进行显示初始化让编译器将定义对象的类型设置为初始化值的类型。举个例子
int main(){int i 10;auto p &i;auto pf strcpy;cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;map<string, string> dict { {sort, 排序}, {insert, 插入} };//map<string, string>::iterator it dict.begin();auto it dict.begin();return 0;}我们使用typeid只能查看数据类型而不能使用它来创建新的变量此时我们就需要使用decltype举例如下
class A{private:decltype(malloc) pf2;};template<class Func>class B{private:Func _f;};int main(){auto pf malloc;auto pf1 pf;// decltype推出对象的类型再定义变量或者作为模板实参// 单纯先定义一个变量出现decltype(pf) pf2;B<decltype(pf)> bb1;const int x 1;double y 2.2;B<decltype(x * y)> bb2;return 0;}由于C中NULL被定义成字面量0这样就可能会带来一些问题因为0既能指针常量又能表示整形常量。所以出于清晰和安全的角度考虑C11中新增了nullptr用于表示空指针。
在C中NULL的定义如下
#ifndef NULL#ifdef __cplusplus#define NULL 0#else#define NULL ((void *)0)#endif#endif在C98中如果要遍历一个数组可以按照以下方式进行
int main(){int array[] { 1, 2, 3, 4, 5 };for (int i 0; i < sizeof(array) / sizeof(array[0]); i){array[i] * 2;}for (int* p array; p < array sizeof(array) / sizeof(array[0]); p){cout << *p << endl;}return 0;}对于一个有范围的集合而言由程序员来说明循环的范围是多余的有时候还会容易犯错误。因此C11中引入了基于范围的for循环。for循环后的括号由冒号“ ”分为两部分第一部分是范围内用于迭代的变量第二部分则表示被迭代的范围。示例如下
int main(){int array[] { 1, 2, 3, 4, 5 };for (auto& e : array){e * 2;}for (auto e : array){cout << e << ;}return 0;}注与普通循环类似可以用continue来结束本次循环也可以用break来跳出整个循环。
4.右值引用与移动语义 ①左值引用与右值引用在我们之前的学习中我们已经知道了引用的语法而C11中新增了的右值引用语法特性所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用都是给对象取别名。既然如此那么什么是左值什么是右值呢首先是左值
左值是一个表示数据的表达式(如变量名或解引用的指针)我们可以获取它的地址也可以对它赋值左值可以出现在赋值符号的左边右值不能出现在赋值符号左边。定义时const修饰符后的左值不能赋值但是可以取它的地址。左值引用就是给左值的引用给左值取别名。
举几个例子
int main(){// 以下的p、b、c、*p都是左值int* p new int(0);int b 1;const int c 2;// 以下几个是对上面左值的左值引用int*& rp p;int& rb b;const int& rc c;int& pvalue *p;return 0;}那什么是右值呢
右值也是一个表示数据的表达式如字面常量、表达式返回值函数返回值(这个不能是左值引用返回)等等右值可以出现在赋值符号的右边但是不能出现出现在赋值符号的左边右值不能取地址。右值引用就是对右值的引用给右值取别名。
举几个例子
int main(){double x 1.1, y 2.2;// 以下几个都是常见的右值10;x y;fmin(x, y);// 以下几个都是对右值的右值引用int&& rr1 10;double&& rr2 x y;double&& rr3 fmin(x, y);// 编译报错: error C2106: “”: 左操作数必须为左值10 1;x y 1;fmin(x, y) 1;return 0;}不难看出区别一个数据是左值还是右值只需要看能否被取地址能就是左值不能就是右值。
②左值引用与右值引用的比较对于左值引用我们总结如下
1. 左值引用只能引用左值不能引用右值。
2. 但是const左值引用既可引用左值也可引用右值。
举个例子
int main(){// 左值引用只能引用左值不能引用右值。int a 10;int& ra1 a; // ra为a的别名//int& ra2 10; // 编译失败因为10是右值// const左值引用既可引用左值也可引用右值。const int& ra3 10;const int& ra4 a;return 0;}对于右值引用我们总结如下
1. 右值引用只能右值不能引用左值。
2. 但是右值引用可以move以后的左值。
举几个例子
int main(){// 右值引用只能右值不能引用左值。int&& r1 10;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用int a 10;int&& r2 a;// 右值引用可以引用move以后的左值int&& r3 std::move(a);return 0;}注move实际上在使用后会将move的资源转移到右值引用的对象这之后自己会被置空。
③左值引用与右值引用的使用场景与意义、移动语义在前面的总结中我们可以发现左值引用既可以引用左值又可以引用右值那么右值引用的存在有何意义呢其实左值引用在一些场景之中具有一些短板右值引用则可以弥补这些短板。
在这里我们使用之前模拟实现的string类作为参考即String类的模拟实现并对其做一些改造调用相对的函数的打印一下方便我们进行观察我们已经知道引用的价值是作为参数与返回值在如下的一些场景中左值引用都能起到很好的作用
void func1(my_string::string s){}void func2(const my_string::string& s){}int main(){my_string::string s1(hello world);// func1和func2的调用我们可以看到// 左值引用做参数减少了拷贝提高效率的使用场景和价值func1(s1);func2(s1);// string operator(char ch) 传值返回存在深拷贝// string& operator(char ch) 传左值引用没有使用深拷贝从而提高了效率s1 !;return 0;}运行有
但是当函数返回对象是一个局部变量时出了函数作用域就不存在了就不能使用左值引用返回只能传值返回。举个例子
my_string::string func(){ my_string::string str aaaaaaaaaa; //... return str;}可以看到这里只能使用传值返回而传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
func的返回值是一个右值用这个右值构造ret1如果没有移动构造调用就会匹配调用拷贝构造因为const左值引用是可以引用右值的这里就是一个深拷贝。为了解决上述的问题我们可以在my_string::string中增加移动构造移动构造本质是将参数右值的资源窃取过来占位已有那么就不用做深拷贝了所以它叫做移动构造就是窃取别人的资源来构造自己。
// 移动构造string(string&& s) :_str(nullptr) ,_size(0) ,_capacity(0){ cout << string(string&& s) -- 移动构造 << endl; swap(s);}再运行上面func时我们会发现这里没有调用深拷贝的拷贝构造而是调用了移动构造移动构造中没有新开空间和拷贝数据所以效率提高了。因为这里func的返回值是一个右值用这个右值构造ret1如果既有拷贝构造又有移动构造,调用就会自动匹配调用移动构造因为编译器会选择最匹配的参数调用。那么这里就是一个移动语义
除了移动构造外还有移动赋值我们向my_string::string中添加下列移动赋值函数
// 移动赋值string& operator(string&& s){ cout << string& operator(string&& s) -- 移动赋值 << endl; swap(s); return *this;}此时再运行下列代码有
这里运行后我们看到调用了移动赋值。因为如果是用一个已经存在的对象接收编译器就没办法优化了。这里会先用str生成构造生成一个临时对象然后在把这个临时对象做为func函数调用的返回值赋值给ret1这里调用了移动赋值。具体来说移动构造和移动赋值都是在返回临时对象时编译器会自动将这个临时对象认定为将亡值然后对其使用移动语义通俗一点来说就是编译器认为“你反正都要没了不如把你的所有资源给另一个人然后自己什么都不带再去世”。
④右值引用引用左值及其一些更深入的使用场景分析按照语法右值引用只能引用右值但右值引用一定不能引用左值吗因为有些场景下可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时可以通过move函数将左值转化为右值。C11中std::move()函数位于头文件中该函数名字具有迷惑性它并不搬移任何东西唯一的功能就是将一个左值强制转化为右值引用然后实现移动语义。
对于下面这段代码
int main(){ my_string::string s1(hello world); // 这里s1是左值调用的是拷贝构造 my_string::string s2(s1); my_string::string s3(std::move(s1)); return 0;}运行之后可以发现经过move之后s1的资源被置空因为其所有资源都被转移给了s3
此外在C11中容器的插入接口也都加入了右值引用版本举几个例子
这里我们用list的插入接口来举例
int main(){ list<my_string::string> v; my_string::string s1(1111); // 这里调用的是拷贝构造 v.push_back(s1); // 下面调用都是移动构造 v.push_back(2222); v.push_back(std::move(s1)); return 0;}即第一个push_back插入newnode时string里面的数据需要深拷贝一份供newnode使用而后面的push_back插入时因为传入的string被编译器认定为将亡值直接使用其移动构造一份数据供newnode使用这样就减少了需要拷贝的次数。
综上所述我们可以知道使用右值引用的场景大概有两种第一种是自定义类型在某个函数中含有深拷贝且必须使用传值返回的情况第二种则是在容器的插入接口中如果待插入的对象为右值可以利用移动构造将其资源转移到数据结构中。
⑤完美转发 1.模板中的&&、万能引用我们先来看下面这段代码
void Fun(int& x) { cout << 左值引用 << endl; }void Fun(const int& x) { cout << const 左值引用 << endl; }void Fun(int&& x) { cout << 右值引用 << endl; }void Fun(const int&& x) { cout << const 右值引用 << endl; }template<typename T>void PerfectForward(T&& t){ Fun(t);}int main(){ PerfectForward(10); int a; PerfectForward(a); PerfectForward(std::move(a)); const int b 8; PerfectForward(b); PerfectForward(std::move(b)); return 0;}在运行之后可以发现
这与我们理想中想要的到的答案略有差异其实模板中的&&不代表右值引用而是万能引用其既能接收左值又能接收右值。模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力但是引用类型的唯一作用就是限制了接收的类型后续使用中都退化成了左值我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
2.std::forward 完美转发在传参的过程中保留对象原生类型属性我们只需要使用std::forward就可以保留对象的原生类型属性即
void Fun(int& x) { cout << 左值引用 << endl; }void Fun(const int& x) { cout << const 左值引用 << endl; }void Fun(int&& x) { cout << 右值引用 << endl; }void Fun(const int&& x) { cout << const 右值引用 << endl; }template<typename T>void PerfectForward(T&& t){ Fun(std::forward<T>(t));}int main(){ PerfectForward(10); int a; PerfectForward(a); PerfectForward(std::move(a)); const int b 8; PerfectForward(b); PerfectForward(std::move(b)); return 0;}此时我们再次运行有
这样就达到了我们想要的效果
3.完美转发实际中的使用场景在这里举list为例
template<class T>struct ListNode{ ListNode* _next nullptr; ListNode* _prev nullptr; T _data;};template<class T>class List{ typedef ListNode<T> Node;public: List() { _head new Node; _head->_next _head; _head->_prev _head; } void PushBack(T&& x) { //Insert(_head, x); Insert(_head, std::forward<T>(x)); } void PushFront(T&& x) { //Insert(_head->_next, x); Insert(_head->_next, std::forward<T>(x)); } void Insert(Node* pos, T&& x) { Node* prev pos->_prev; Node* newnode new Node; newnode->_data std::forward<T>(x); // 关键位置 // prev newnode pos prev->_next newnode; newnode->_prev prev; newnode->_next pos; pos->_prev newnode; } void Insert(Node* pos, const T& x) { Node* prev pos->_prev; Node* newnode new Node; newnode->_data x; // 关键位置 // prev newnode pos prev->_next newnode; newnode->_prev prev; newnode->_next pos; pos->_prev newnode; }private: Node* _head;};可以看到在push_back(T&& x)中调用insert函数时必须使用forward将其原生属性保留下来否则在后续的传递过程中x会变为左值引用这会使得前面的右值引用传递变得无效这点在insert函数中同样有所体现总结就是在传递右值引用参数时需要不断使用forward函数使其保持原生属性。
5.STL的变化 ①新容器C11中新增的容器即用红框圈起来的几个而比较有价值的容器只有unorder_set与unorder_maparray设计出来对标的是C语言中的数组相比较而言唯一的优势可能是对数组越界的检查比较严格
②容器中的一些新接口 1.迭代器接口新增了const版本的迭代器但是本身使用begin也能够很好的解决问题所以实际意义不大
2.所有容器均支持了{}列表初始化的构造函数举几个例子
这使得我们初始化容器时更加方便即可以用{}来初始化容器
3.所有容器均新增了emplace系列这里使用了万能引用与可变模板参数最终的目的是提高插入效率它可以在容器的末尾直接构造一个元素省去了先构造元素再插入的步骤提高了效率。
4.容器新增了移动构造与移动赋值有了移动构造与移动赋值之后在某些场景下效率大大提升
6.类的变化 ①默认成员函数原来C类中有6个默认成员函数
1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载
C11 新增了两个移动构造函数和移动赋值运算符重载。需要注意的是
如果你没有自己实现移动构造函数且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数对于内置类型成员会执行逐成员按字节拷贝自定义类型成员则需要看这个成员是否实现移动构造如果实现了就调用移动构造没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数对于内置类型成员会执行逐成员按字节拷贝自定义类型成员则需要看这个成员是否实现移动赋值如果实现了就调用移动赋值没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值编译器不会自动提供拷贝构造和拷贝赋值。
我们可以使用如下代码测试
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& operator(const Person& p) //{ //if(this ! &p) //{ //_name p._name; //_age p._age; //} //return *this; //} //~Person() //{}private: my_string::string _name; int _age;};int main(){ Person s1; Person s2 s1; Person s3 std::move(s1); Person s4; s4 std::move(s2); return 0;}C11允许在类定义时给成员变量初始缺省值默认生成构造函数会使用这些缺省值初始化这个我们在类和对象提到过这里就不再展开讲了。
③强制生成默认函数的关键字defaultC11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数但是因为一些原因这个函数没有默认生成。比如我们提供了拷贝构造就不会生成移动构造了那么我们可以使用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: my_string::string _name; int _age;};int main(){ Person s1; Person s2 s1; Person s3 std::move(s1); return 0;}如果能想要限制某些默认函数的生成在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: my_string::string _name; int _age;};int main(){ Person s1; Person s2 s1; Person s3 std::move(s1); return 0;}这两个关键字在继承与多态中已经提到过详见C基础语法——继承。
7.可变参数模板C11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板相比C98/03类模版和函数模版中只能含固定数量的模版参数可变模版参数无疑是一个巨大的改进。举个例子
// Args是一个模板参数包args是一个函数形参参数包// 声明一个参数包Args...args这个参数包中可以包含0到任意个模板参数。template <class ...Args>void ShowList(Args... args){}上面的参数args前面有省略号所以它就是一个可变模版参数我们把带省略号的参数称为“参数包”它里面包含了0到NN>0个模版参数。我们无法直接获取参数包args中的每个参数的只能通过展开参数包的方式来获取参数包中的每个参数这是使用可变模版参数的一个主要特点也是最大的难点即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数所以我们的用一些特殊的方法来获取参数包的值。
①使用递归函数方式展开参数包举例代码如下
// 递归终止函数template <class T>void ShowList(const T& t){ cout << t << endl;}// 展开函数template <class T, class ...Args>void ShowList(T value, Args... args){ cout << value << ; ShowList(args...);}int main(){ ShowList(1); ShowList(1, A); ShowList(1, A, std::string(sort)); return 0;}这里的展开方式是每次获取一个value然后将剩下的参数继续向后传最终传到只有一个参数时终止
②使用逗号表达式展开参数包这种展开参数包的方式不需要通过递归终止函数是直接在expand函数体中展开的, printarg不是一个递归终止函数只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand函数中的逗号表达式(printarg(args), 0)也是按照这个执行顺序先执行printarg(args)再得到逗号表达式的结果0。同时还用到了C11的另外一个特性——初始化列表通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。由于是逗号表达式在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数也就是说在构造int数组的过程中就将参数包展开了这个数组的目的纯粹是为了在数组构造的过程展开参数包
举例如下
template <class T>void PrintArg(T t){ cout << t << ;}//展开函数template <class ...Args>void ShowList(Args... args){ int arr[] { (PrintArg(args), 0)... }; cout << endl;}int main(){ ShowList(1); ShowList(1, A); ShowList(1, A, std::string(sort)); return 0;}template <class... Args>void emplace_back(Args&&... args);首先我们看到的emplace系列的接口支持模板的可变参数并且万能引用。那么相对insert和
emplace系列接口的优势到底在哪里呢
int main(){ std::list< std::pair<int, char> > mylist; // emplace_back支持可变参数拿到构建pair对象的参数后自己去创建对象 // 那么在这里我们可以看到除了用法上和push_back没什么太大的区别 mylist.emplace_back(10, a); mylist.emplace_back(20, b); mylist.emplace_back(make_pair(30, c)); mylist.push_back(make_pair(40, d)); mylist.push_back({ 50, e }); for (auto e : mylist) cout << e.first << : << e.second << endl; return 0;}int main(){ // 下面我们试一下带有拷贝构造和移动构造的my_string::string再试试呢 // 我们会发现其实差别也不到emplace_back是直接构造了push_back // 是先构造再移动构造其实也还好。 std::list< std::pair<int, my_string::string> > mylist; mylist.emplace_back(10, sort); mylist.emplace_back(make_pair(20, sort)); mylist.push_back(make_pair(30, sort)); mylist.push_back({ 40, sort }); return 0;}即
8.lambda表达式 ①C98中的一种情况在C98中如果想要对一个数据集合中的元素进行排序可以使用std::sort方法。举个例子
int main(){ int array[] { 4,1,8,5,3,7,0,9,2,6 }; // 默认按照小于比较排出来结果是升序 std::sort(array, array sizeof(array) / sizeof(array[0])); // 如果需要降序需要改变元素的比较规则 std::sort(array, array sizeof(array) / sizeof(array[0]), greater<int>()); return 0;}如果待排序元素为自定义类型需要我们自己定义排序时的比较规则即
struct Goods{ Goods(const char* str, double price, int evaluate) :_name(str) , _price(price) , _evaluate(evaluate) {} string _name; // 名字 double _price; // 价格 int _evaluate; // 评价};struct ComparePriceLess{ bool operator()(const Goods& gl, const Goods& gr) { return gl._price < gr._price; }};struct ComparePriceGreater{ bool operator()(const Goods& gl, const Goods& gr) { return gl._price > gr._price; }};int main(){ vector<Goods> v { { 苹果, 2.1, 5 }, { 香蕉, 3, 4 }, { 橙子, 2.2, 3 }, { 菠萝, 1.5, 4 } }; sort(v.begin(), v.end(), ComparePriceLess()); sort(v.begin(), v.end(), ComparePriceGreater()); return 0;}随着C语法的发展人们开始觉得上面的写法太复杂了每次为了实现一个algorithm算法都要重新去写一个类如果每次比较的逻辑不一样还要去实现多个类特别是相同类的命名这些都给编程者带来了极大的不便。因此在C11语法中出现了Lambda表达式。
②lambda表达式下面的代码就是使用C11中的lambda表达式来解决可以看出lambda表达式实际是一个匿名函
数。
int main(){ vector<Goods> v { { 苹果, 2.1, 5 }, { 香蕉, 3, 4 }, { 橙子, 2.2, 3 }, { 菠萝, 1.5, 4 } }; 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;}lambda表达式书写格式[capture-list] (parameters) mutable -> return-type { statement }
lambda表达式各部分说明
[capture-list] : 捕捉列表该列表总是出现在lambda函数的开始位置编译器根据[]来判断接下来的代码是否为lambda函数捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)参数列表。与普通函数的参数列表一致如果不需要参数传递则可以连同()一起省略
mutable默认情况下lambda函数总是一个const函数mutable可以取消其常量性。使用该修饰符时参数列表不可省略(即使参数为空)。
->returntype返回值类型。用追踪返回类型形式声明函数的返回值类型没有返回值时此部分可省略。返回值类型明确情况下也可省略由编译器对返回类型进行推导。
{statement}函数体。在该函数体内除了可以使用其参数外还可以使用所有捕获到的变量。
注在lambda函数定义中参数列表和返回值类型都是可选部分而捕捉列表和函数体可以为
空。因此C11中最简单的lambda函数为[]{}; 该lambda函数不能做任何事情。
捕捉列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用以及使用的方式传值还是传引用。
[var]表示值传递方式捕捉变量var
[]表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]表示引用传递捕捉变量var
[&]表示引用传递捕捉所有父作用域中的变量(包括this)
[this]表示值传递方式捕捉当前的this指针
注
a. 父作用域指包含lambda函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成并以逗号分割。如
[, &a, &b]以引用传递的方式捕捉变量a和b值传递方式捕捉其他所有变量
[&a, this]值传递方式捕捉变量a和this引用方式捕捉其他变量
c. 捕捉列表不允许变量重复传递否则就会导致编译错误。如
[, a]已经以值传递方式捕捉了所有变量捕捉a重复
d. 在块作用域以外的lambda函数捕捉列表必须为空。
e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量捕捉任何非此作用域或者非局部变量都会导致编译报错。
f. lambda表达式之间不能相互赋值即使看起来类型相同
下面我们就来举几个例子方便我们了解lambda表达式
// 例一int main(){int a 0, b 2;double rate 2.555;auto add1 [](int x, int y)->int {return x y; };auto add2 [](int x, int y) {return x y; };auto add3 [rate](int x, int y) {return (x y)* rate; };cout << add1(a, b) << endl;cout << add2(a, b) << endl;cout << add3(a, b) << endl;auto swap1 [add1](int& x, int& y) {int tmp x;x y;y tmp;cout << add1(x, y) << endl;};swap1(a, b);return 0;}// 例二int main(){int x 0, y 2;auto swap1 [x, y]() mutable {// mutable让捕捉的x和y可以改变了// 但是他们依旧是外面x和y的拷贝int tmp x;x y;y tmp;};swap1();// 引用的方式捕捉auto swap2 [&x, &y](){int tmp x;x y;y tmp;};swap2();int a 0;int b 1;int c 2;int d 3;const int e 1;cout << &e << endl;// 引用的方式捕捉所有对象除了a// a用传值的方式捕捉auto func [&, a] {//a;b;c;d;cout << &e << endl;};return 0;}// 例三int main(){auto f1 [](int x, int y) {return x y; };auto f2 [](int x, int y) {return x y; };//f1 f2;cout << typeid(f1).name() << endl;cout << typeid(f2).name() << endl;f1(1, 2);return 0;}在这里f1看似等于f2但它们的类型名称还是略有差异
④函数对象与lambda表达式函数对象又称为仿函数即可以想函数一样使用的对象就是在类中重载了operator()运算符的类对象。我们将其与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;Rate r1(rate);r1(10000, 2);// lambdaauto r2 [](double monty, int year)->double {return monty * rate * year; };r2(10000, 2);return 0;}查看其反汇编指令后我们可以发现
从使用方式上来看函数对象与lambda表达式完全一样。实际在底层编译器对于lambda表达式的处理方式完全就是按照函数对象的方式处理的即如果定义了一个lambda表达式编译器会自动生成一个类在该类中重载了operator()。
9.包装器 ①function包装器function包装器 也叫作适配器。C中的function本质是一个类模板也是一个包装器。那么我们来看看我们为什么需要function呢在 ret func(x); 这个语句中的func可能是什么呢func可能是函数名函数指针函数对象(仿函数对象)也有可能是lambda表达式对象所以这些都是可调用的类型如此丰富的类型可能会导致模板的效率低下
先看下面一段代码
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, 11.11) << endl; // 函数对象 cout << useF(Functor(), 11.11) << endl; // lamber表达式 cout << useF([](double d)->double { return d / 4; }, 11.11) << endl; return 0;}运行后我们可以发现
通过上面的程序验证我们会发现useF函数模板实例化了三份。而包装器可以很好的解决上面的问题其类模板原型如下
template <class T> function; // undefinedtemplate <class Ret, class... Args>class function<Ret(Args...)>;注Ret: 被调用函数的返回类型Args…被调用函数的形参
接下来举个例子
// 包装器 -- 可调用对象的类型问题function<double(double)> f1 f;function<double(double)> f2 [](double d)->double { return d / 4; };function<double(double)> f3 Functor();//vector<function<double(double)>> v { f1, f2, f3 };vector<function<double(double)>> v { f, [](double d)->double { return d / 4; }, Functor() };double n 3.3;for (auto f : v){cout << f(n) << endl;}既然如此那么我们也可以利用包装器来解决之前的效率问题
int main(){// 函数名std::function<double(double)> func1 f;cout << useF(func1, 11.11) << endl;// 函数对象std::function<double(double)> func2 Functor();cout << useF(func2, 11.11) << endl;// lambda表达式std::function<double(double)> func3 [](double d)->double { return d / 4; };cout << useF(func3, 11.11) << endl;return 0;}运行有
可以看到在这里useF只实例化出了一份提升了效率此外它还可以应用到一些其他场景举个例子在逆波兰表达式求值 这道题中没有学习包装器前我们使用的是switch case语句解决即
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(); }};而在学习了包装器之后我们可以这样解决
class Solution {public: int evalRPN(vector<string>& tokens) { stack<int> st; map<string, function<int(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 { st.push(stoi(str)); } } return st.top(); }};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函数看作是一个通用的函数适配器它接受一个可调用对象生成一个新的可调用对
象来“适应”原对象的参数列表。调用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为第二个参数以此类推。
让我们举几个例子
int Sub(int a, int b){ return a - b;}double Plus(int a, int b, double rate){ return (a b) * rate;}double PPlus(int a, double rate, int b){ return rate * (a b);}class Sub{public:int sub(int a, int b){return a - b;}};class SubType{public: static int sub(int a, int b) { return a - b; } int ssub(int a, int b, int rate) { return (a - b) * rate; }};int main(){/*function<int(int, int)> rSub bind(Sub, placeholders::_1, placeholders::_2);cout << rSub(10, 5) << endl;*/ // int Sub(int a, int b)function<int(int, int)> rSub bind(Sub, placeholders::_2, placeholders::_1);cout << rSub(10, 5) << endl; // double Plus(int a, int b, double rate)function<double(int, int)> Plus1 bind(Plus, placeholders::_1, placeholders::_2, 4.0);function<double(int, int)> Plus2 bind(Plus, placeholders::_1, placeholders::_2, 4.2);function<double(int, int)> Plus3 bind(Plus, placeholders::_1, placeholders::_2, 4.4);cout << Plus1(5, 3) << endl;cout << Plus2(5, 3) << endl;cout << Plus3(5, 3) << endl;// double PPlus(int a, double rate, int b)function<double(int, int)> PPlus1 bind(PPlus, placeholders::_1, 4.0, placeholders::_2);function<double(int, int)> PPlus2 bind(PPlus, placeholders::_1, 4.2, placeholders::_2);cout << PPlus1(5, 3) << endl;cout << PPlus2(5, 3) << endl; // static int sub(int a, int b)function<double(int, int)> Sub1 bind(&SubType::sub, placeholders::_1, placeholders::_2); // int ssub(int a, int b, int rate)SubType st;function<double(int, int)> Sub2 bind(&SubType::ssub, &st, placeholders::_1, placeholders::_2, 3);cout << Sub1(1, 2) << endl;cout << Sub2(1, 2) << endl;function<double(int, int)> Sub3 bind(&SubType::ssub, SubType(), placeholders::_1, placeholders::_2, 3);cout << Sub3(1, 2) << endl;cout << typeid(Sub3).name() << endl;return 0;}运行有
部分对应情况如图所示
bind函数可以在我们遇见一些自己不习惯或者感觉参数顺序不对时按自己喜欢的方式来对应参数位置