【C++11】可变参数模板/新的类功能/lambda/包装器--C++

Ne0inhk

— 26 min read
【C++11】可变参数模板/新的类功能/lambda/包装器--C++

文章目录

一、可变参数模板

1、基本语法及原理

  1. C++11支持可变参数模板，也就是说支持可变数量参数的函数模板和类模板，可变数目的参数被称为参数包，存在两种参数包：模板参数包，表示零或多个模板参数；函数参数包：表示零或多个函数参数。
  2. template <class ...Args> void Func(Args... args) {}
  3. template <class ...Args> void Func(Args&... args) {}
  4. template <class ...Args> void Func(Args&&... args) {}
  5. 我们用省略号来指出一个模板参数或函数参数的表示一个包，在模板参数列表中，class…或typename…指出接下来的参数表示零或多个类型列表；在函数参数列表中，类型名后面跟…指出接下来表示零或多个形参对象列表；函数参数包可以用左值引用或右值引用表示，跟前面普通模板一样，每个参数实例化时遵循引用折叠规则。
  6. 可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。
  7. 这里我们可以使用sizeof…运算符去计算参数包中参数的个数。
template<class...Args>voidPrint(Args&&... args){ cout <<sizeof...(args)<< endl;}intmain(){double x =2.2;Print();// 包⾥有0个参数Print(1);// 包⾥有1个参数Print(1,string("xxxxx"));// 包⾥有2个参数Print(1.1,string("xxxxx"), x);// 包⾥有3个参数return0;}// 原理1：编译本质这⾥会结合引⽤折叠规则实例化出以下四个函数voidPrint();voidPrint(int&& arg1);voidPrint(int&& arg1, string&& arg2);voidPrint(double&& arg1, string&& arg2,double& arg3);// 原理2：更本质去看没有可变参数模板，我们实现出这样的多个函数模板才能⽀持// 这⾥的功能，有了可变参数模板，我们进⼀步被解放，他是类型泛化基础// 上叠加数量变化，让我们泛型编程更灵活。voidPrint();template<classT1>voidPrint(T1&& arg1);template<classT1,classT2>voidPrint(T1&& arg1, T2&& arg2);template<classT1,classT2,classT3>voidPrint(T1&& arg1, T2&& arg2, T3&& arg3);// ...

2、包扩展

  1. 对于一个参数包，我们除了能计算他的参数个数，我们能做的唯一的事情就是扩展它，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(…)来触发扩展操作。底层的实现细节如图1所示。
  2. C++还支持更复杂的包扩展，直接将参数包依次展开依次作为实参给一个函数去处理。
在这里插入图片描述
// 可变模板参数// 参数类型可变// 参数个数可变// 打印参数包内容//template <class ...Args>//void Print(Args... args)//{// // 可变参数模板编译时解析// // 下⾯是运⾏获取和解析，所以不⽀持这样⽤// cout << sizeof...(args) << endl;// for (size_t i = 0; i < sizeof...(args); i++)// {// cout << args[i] << " ";// }// cout << endl;//}voidShowList(){// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;}template<classT,class...Args>voidShowList(T x, Args... args){ cout << x <<" ";// args是N个参数的参数包// 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包ShowList(args...);}// 编译时递归推导解析参数template<class...Args>voidPrint(Args... args){ShowList(args...);}intmain(){Print();Print(1);Print(1,string("xxxxx"));Print(1,string("xxxxx"),2.2);return0;}//template <class T, class ...Args>//void ShowList(T x, Args... args)//{// cout << x << " ";// Print(args...);//}// Print(1, string("xxxxx"), 2.2);调⽤时// 本质编译器将可变参数模板通过模式的包扩展，编译器推导的以下三个重载函数函数//void ShowList(double x)//{// cout << x << " ";// ShowList();//}////void ShowList(string x, double z)//{// cout << x << " ";// ShowList(z);//}////void ShowList(int x, string y, double z)//{// cout << x << " ";// ShowList(y, z);//}//void Print(int x, string y, double z)//{// ShowList(x, y, z);//}
template<classT>const T&GetArg(const T& x){ cout << x <<" ";return x;}template<class...Args>voidArguments(Args... args){}template<class...Args>voidPrint(Args... args){// 注意GetArg必须返回或者到的对象，这样才能组成参数包给ArgumentsArguments(GetArg(args)...);}// 本质可以理解为编译器编译时，包的扩展模式// 将上⾯的函数模板扩展实例化为下⾯的函数// 是不是很抽象，C++11以后，只能说委员会的⼤佬设计语法思维跳跃得太厉害//void Print(int x, string y, double z)//{// Arguments(GetArg(x), GetArg(y), GetArg(z));//}intmain(){Print(1,string("xxxxx"),2.2);return0;}

3、empalce系列接口

  1. template <class... Args> void emplace_back (Args&&... args);
  2. template <class... Args> iterator emplace (const_iterator position, Args&&... args);
  3. C++11以后STL容器新增了empalce系列的接口，empalce系列的接口均为模板可变参数，功能上兼容push和insert系列，但是empalce还支持新玩法，假设容器为container，empalce还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
  4. emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
  5. 第二个程序中我们模拟实现了list的emplace和emplace_back接口，这里把参数包不段往下传递，最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前面说的empalce支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
  6. 传递参数包过程中，如果是 Args&&... args 的参数包，要用完美转发参数包，方式如下std::forward<Args>(args)... ，否则编译时包扩展后右值引用变量表达式就变成了左值。
#include<list>// emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替代insert和push系列intmain(){ list<bit::string> lt;// 传左值，跟push_back⼀样，⾛拷⻉构造 bit::string s1("111111111111"); lt.emplace_back(s1); cout <<"*********************************"<< endl;// 右值，跟push_back⼀样，⾛移动构造 lt.emplace_back(move(s1)); cout <<"*********************************"<< endl;// 直接把构造string参数包往下传，直接⽤string参数包构造string// 这⾥达到的效果是push_back做不到的 lt.emplace_back("111111111111"); cout <<"*********************************"<< endl; list<pair<bit::string,int>> lt1;// 跟push_back⼀样// 构造pair + 拷⻉/移动构造pair到list的节点中data上 pair<bit::string,int>kv("苹果",1); lt1.emplace_back(kv); cout <<"*********************************"<< endl;// 跟push_back⼀样 lt1.emplace_back(move(kv)); cout <<"*********************************"<< endl;////////////////////////////////////////////////////////////////////// 直接把构造pair参数包往下传，直接⽤pair参数包构造pair// 这⾥达到的效果是push_back做不到的 lt1.emplace_back("苹果",1); cout <<"*********************************"<< endl;return0;}
// List.hnamespace bit {template<classT>structListNode{ ListNode<T>* _next; ListNode<T>* _prev; T _data;ListNode(T&& data):_next(nullptr),_prev(nullptr),_data(move(data)){}template<class... Args>ListNode(Args&&... args):_next(nullptr),_prev(nullptr),_data(std::forward<Args>(args)...){}};template<classT,classRef,classPtr>structListIterator{typedef ListNode<T> Node;typedef ListIterator<T, Ref, Ptr> Self; Node* _node;ListIterator(Node* node):_node(node){}// ++it; Self&operator++(){ _node = _node->_next;return*this;} Self&operator--(){ _node = _node->_prev;return*this;} Ref operator*(){return _node->_data;}booloperator!=(const Self& it){return _node != it._node;}};template<classT>classlist{typedef ListNode<T> Node;public:typedef ListIterator<T, T&, T*> iterator;typedef ListIterator<T,const T&,const T*> const_iterator; iterator begin(){returniterator(_head->_next);} iterator end(){returniterator(_head);}voidempty_init(){ _head =newNode(); _head->_next = _head; _head->_prev = _head;}list(){empty_init();}voidpush_back(const T& x){insert(end(), x);}voidpush_back(T&& x){insert(end(),move(x));} iterator insert(iterator pos,const T& x){ Node* cur = pos._node; Node* newnode =newNode(x); Node* prev = cur->_prev;// prev newnode cur prev->_next = newnode; newnode->_prev = prev; newnode->_next = cur; cur->_prev = newnode;returniterator(newnode);} iterator insert(iterator pos, T&& x){ Node* cur = pos._node; Node* newnode =newNode(move(x)); Node* prev = cur->_prev;// prev newnode cur prev->_next = newnode; newnode->_prev = prev; newnode->_next = cur; cur->_prev = newnode;returniterator(newnode);}template<class... Args>voidemplace_back(Args&&... args){insert(end(), std::forward<Args>(args)...);}// 原理：本质编译器根据可变参数模板⽣成对应参数的函数/*void emplace_back(string& s) { insert(end(), std::forward<string>(s)); } void emplace_back(string&& s) { insert(end(), std::forward<string>(s)); } void emplace_back(const char* s) { insert(end(), std::forward<const char*>(s)); } */template<class... Args> iterator insert(iterator pos, Args&&... args){ Node* cur = pos._node; Node* newnode =newNode(std::forward<Args>(args)...); Node* prev = cur->_prev;// prev newnode cur prev->_next = newnode; newnode->_prev = prev; newnode->_next = cur; cur->_prev = newnode;returniterator(newnode);}private: Node* _head;};}// Test.cpp#include"List.h"// emplace_back总体⽽⾔是更⾼效，推荐以后使⽤emplace系列替代insert和push系列intmain(){ bit::list<bit::string> lt;// 传左值，跟push_back⼀样，⾛拷⻉构造 bit::string s1("111111111111"); lt.emplace_back(s1); cout <<"*********************************"<< endl;// 右值，跟push_back⼀样，⾛移动构造 lt.emplace_back(move(s1)); cout <<"*********************************"<< endl;// 直接把构造string参数包往下传，直接⽤string参数包构造string// 这⾥达到的效果是push_back做不到的 lt.emplace_back("111111111111"); cout <<"*********************************"<< endl; bit::list<pair<bit::string,int>> lt1;// 跟push_back⼀样// 构造pair + 拷⻉/移动构造pair到list的节点中data上 pair<bit::string,int>kv("苹果",1); lt1.emplace_back(kv); cout <<"*********************************"<< endl;// 跟push_back⼀样 lt1.emplace_back(move(kv)); cout <<"*********************************"<< endl;////////////////////////////////////////////////////////////////////// 直接把构造pair参数包往下传，直接⽤pair参数包构造pair// 这⾥达到的效果是push_back做不到的 lt1.emplace_back("苹果",1); cout <<"*********************************"<< endl;return0;}

二、新的类功能

1、默认的移动构造和移动赋值

  1. 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址重载/const 取地址重载，最后重要的是前4个，后两个用处不大，默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。
  2. 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
  3. 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
  4. 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
classPerson{public:Person(constchar* 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: bit::string _name;int _age;};intmain(){ Person s1; Person s2 = s1; Person s3 = std::move(s1); Person s4; s4 = std::move(s2);return0;}

2、成员变量声明时给缺省值

成员变量声明时给缺省值是给初始化列表用的，如果没有显示在初始化列表初始化，就会在初始化列表用这个却绳子初始化，这个我们在类和对象部分讲过了,点击跳转,可以查看我的主页哦.

3、defult和delete

  1. C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。
  2. 如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他⼈想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
classPerson{public:Person(constchar* name ="",int age =0):_name(name),_age(age){}Person(const Person& p):_name(p._name),_age(p._age){}Person(Person&& p)=default;//Person(const Person& p) = delete;private: bit::string _name;int _age;};intmain(){ Person s1; Person s2 = s1; Person s3 = std::move(s1);return0;}

4、final与override

这个在继承和多态部分已经进行了详细讲过了，点击跳转.可以关注我,看我的主页哦.

三、STL中一些变化

  1. 下图1圈起来的就是STL中的新容器，但是实际最有用的是unordered_map和unordered_set。这两个前面已经进行了详细讲解,可以看我的主页查看相关内容
  2. STL中容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列接口和移动构造和移动赋值，还有initializer_list版本的构造等，还有一些如cbegin/cend等需要时查查文档即可。

容器的范围for遍历，这个在容器部分讲过了。

在这里插入图片描述

四、lambda

1、lambda表达式语法

  1. lambda 表达式本质是一个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。lambda 表达式语法使用层而言没有类型，所以我们一般是用auto或者模板参数定义的对象去接收 lambda 对象。
  2. lambda表达式的格式： [capture-list] (parameters)-> return type { function boby }
  3. [capture-list] : 捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据[]来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用，捕捉列表可以传值和传引用捕捉，具体细节7.2中我们再细讲。捕捉列表为空也不能省略。
  4. (parameters) ：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同()一起省略
  5. ->return type ：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。一般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
  6. {function boby} ：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略。
intmain(){// ⼀个简单的lambda表达式auto add1 =[](int x,int y)->int{return x + y;}; cout <<add1(1,2)<< endl;// 1、捕捉为空也不能省略// 2、参数为空可以省略// 3、返回值可以省略，可以通过返回对象⾃动推导// 4、函数题不能省略auto func1 =[]{ cout <<"hello bit"<< endl;return0;};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;return0;}

2、捕捉列表

  1. lambda 表达式中默认只能用 lambda 函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉
  2. 第一种捕捉方式是在捕捉列表中显示的传值捕捉和传引用捕捉，捕捉的多个变量用逗号分割。[x，y， &z] 表示x和y值捕捉，z引用捕捉。
  3. 第二种捕捉方式是在捕捉列表中隐式捕捉，我们在捕捉列表写一个=表示隐式值捕捉，在捕捉列表写一个&表示隐式引用捕捉，这样我们 lambda 表达式中用了那些变量，编译器就会自动捕捉那些变量。
  4. 第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显示捕捉。[=, &x]表示其他变量隐式值捕捉，x引用捕捉；[&, x, y]表示其他变量引用捕捉，x和y值捕捉。当使用混合捕捉时，第一个元素必须是&或=，并且&混合捕捉时，后面的捕捉变量必须是值捕捉，同理=混合捕捉时，后面的捕捉变量必须是引用捕捉。
  5. lambda 表达式如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉， lambda 表达式中可以直接使用。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
  6. 默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改，mutable加在参数列表的后面可以取消其常量性，也就说使用该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使用该修饰符后，参数列表不可省略(即使参数为空)。
int x =0;// 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量auto func1 =[](){ x++;};intmain(){// 只能⽤当前lambda局部域和捕捉的对象和全局对象int a =0, b =1, c =2, d =3;auto func1 =[a,&b]{// 值捕捉的变量不能修改，引⽤捕捉的变量可以修改//a++; b++;int ret = a + b;return ret;}; cout <<func1()<< endl;// 隐式值捕捉// ⽤了哪些变量就捕捉哪些变量auto func2 =[=]{int ret = a + b + c;return ret;}; cout <<func2()<< endl;// 隐式引⽤捕捉// ⽤了哪些变量就捕捉哪些变量auto func3 =[&]{ a++; c++; d++;};func3(); cout << a <<" "<< b <<" "<< c <<" "<< d <<endl;// 混合捕捉1auto func4 =[&, a, b]{//a++;//b++; c++; d++;return a + b + c + d;};func4(); cout << a <<" "<< b <<" "<< c <<" "<< d << endl;// 混合捕捉1auto func5 =[=,&a,&b]{ a++; b++;/*c++; d++;*/return a + b + c + d;};func5(); cout << a <<" "<< b <<" "<< c <<" "<< d << endl;// 局部的静态和全局变量不能捕捉，也不需要捕捉staticint m =0;auto func6 =[]{int ret = x + m;return ret;};// 传值捕捉本质是⼀种拷⻉,并且被const修饰了// mutable相当于去掉const属性，可以修改了// 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉auto func7 =[=]()mutable{ a++; b++; c++; d++;return a + b + c + d;}; cout <<func7()<< endl; cout << a <<" "<< b <<" "<< c <<" "<< d << endl;return0;}

3、lambda的应用

  1. 在学习 lambda 表达式之前，我们的使用的可调用对象只有函数指针和仿函数对象，函数指针的类型定义起来比较麻烦，仿函数要定义一个类，相对会比较麻烦。使用 lambda 去定义可调用对象，既简单又方便。
  2. lambda 在很多其他地方用起来也很好用。比如线程中定义线程的执行函数逻辑，智能指针中定制删除器等， lambda 的应用还是很⼴泛的，以后我们会不断接触到。
structGoods{ string _name;// 名字double _price;// 价格int _evaluate;// 评价// ...Goods(constchar* str,double price,int evaluate):_name(str),_price(price),_evaluate(evaluate){}};structComparePriceLess{booloperator()(const Goods& gl,const Goods& gr){return gl._price < gr._price;}};structComparePriceGreater{booloperator()(const Goods& gl,const Goods& gr){return gl._price > gr._price;}};intmain(){ vector<Goods> v ={{"苹果",2.1,5},{"⾹蕉",3,4},{"橙⼦",2.2,3},{"菠萝",1.5,4}};// 类似这样的场景，我们实现仿函数对象或者函数指针⽀持商品中// 不同项的⽐较，相对还是⽐较⿇烦的，那么这⾥lambda就很好⽤了sort(v.begin(), v.end(),ComparePriceLess());sort(v.begin(), v.end(),ComparePriceGreater());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;});return0;}

4、lambda的原理

  1. lambda 的原理和范围for很像，编译后从汇编指令层的角度看，压根就没有 lambda 和范围for这样的东西。范围for底层是迭代器，而lambda底层是仿函数对象，也就说我们写了一个lambda 以后，编译器会生成一个对应的仿函数的类。
  2. 仿函数的类名是编译按一定规则生成的，保证不同的 lambda 生成的类名不同，lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使用哪些就传那些对象。
  3. 上面的原理，我们可以透过汇编层了解一下，下面第二段汇编层代码印证了上面的原理。
classRate{public:Rate(double rate):_rate(rate){}doubleoperator()(double money,int year){return money * _rate * year;}private:double _rate;};intmain(){double rate =0.49;// lambdaauto r2 =[rate](double money,int year){return money * rate * year;};// 函数对象 Rate r1(rate);r1(10000,2);r2(10000,2);auto func1 =[]{ cout <<"hello world"<< endl;};func1();return0;}
// lambdaauto r2 =[rate](double money,int year){return money * rate * year;};// 捕捉列表的rate，可以看到作为lambda_1类构造函数的参数传递了，这样要拿去初始化成员变量// 下⾯operator()中才能使⽤00D8295C lea eax,[rate]00D8295F push eax 00D82960 lea ecx,[r2]00D82963 call `main'::`2'::<lambda_1>::<lambda_1>(0D81F80h)// 函数对象 Rate r1(rate);00D82968 sub esp,800D8296B movsd xmm0,mmword ptr [rate]00D82970 movsd mmword ptr [esp],xmm0 00D82975 lea ecx,[r1]00D82978 call Rate::Rate(0D81438h)r1(10000,2);00D8297D push 200D8297F sub esp,800D82982 movsd xmm0,mmword ptr [__real@40c3880000000000(0D89B50h)]00D8298A movsd mmword ptr [esp],xmm0 00D8298F lea ecx,[r1]00D82992 call Rate::operator()(0D81212h)// 汇编层可以看到r2 lambda对象调⽤本质还是调⽤operator()，类型是lambda_1,这个类型名// 的规则是编译器⾃⼰定制的，保证不同的lambda不冲突r2(10000,2);00D82999 push 200D8299B sub esp,800D8299E movsd xmm0,mmword ptr [__real@40c3880000000000(0D89B50h)]00D829A6 movsd mmword ptr [esp],xmm0 00D829AB lea ecx,[r2]00D829AE call `main'::`2'::<lambda_1>::operator()(0D824C0h)

五、包装器

1、function

template<classT>classfunction;// undefinedtemplate<classRet,class... Args>classfunction<Ret(Args...)>;
  1. std::function 是一个类模板，也是一个包装器。 std::function 的实例对象可以包装存储其他的可以调用对象，包括函数指针、仿函数、 lambda 、 bind 表达式等，存储的可调用对象被称为 std::function 的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出std::bad_function_call 异常。
  2. 以上是 function 的原型，他被定义头文件中。std::function - cppreference.com是function的官方文件链接。
  3. 函数指针、仿函数、 lambda 等可调用对象的类型各不相同, std::function 的优势就是统一类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型，下面的第二个代码样例展示了 std::function 作为map的参数，实现字符串和可调用对象的映射表功能。
#include<functional>intf(int a,int b){return a + b;}structFunctor{public:intoperator()(int a,int b){return a + b;}};classPlus{public:Plus(int n =10):_n(n){}staticintplusi(int a,int b){return a + b;}doubleplusd(double a,double b){return(a + b)* _n;}private:int _n;};intmain(){// 包装各种可调⽤对象 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;// 包装静态成员函数// 成员函数要指定类域并且前⾯加&才能获取地址 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;return0;}

2、bind

simple(1)template<classFn,class... Args>/* unspecified */bind(Fn&& fn, Args&&... args); with returntype(2)template<classRet,classFn,class... Args>/* unspecified */bind(Fn&& fn, Args&&... args);
  1. bind 是一个函数模板，它也是一个可调用对象的包装器，可以把他看做一个函数适配器，对接收的fn可调用对象进行处理后返回一个可调用对象。 bind 可以用来调整参数个数和参数顺序。bind 也在这个头文件中。
  2. 调用bind的一般形式： auto newCallable = bind(callable,arg_list); 其中
    newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数。
  3. arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是占位符，表示newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。_1/_2/_3…这些占位符放到placeholders的一个命名空间中。
#include<functional>using placeholders::_1;using placeholders::_2;using placeholders::_3;intSub(int a,int b){return(a - b)*10;}intSubX(int a,int b,int c){return(a - b - c)*10;}classPlus{public:staticintplusi(int a,int b){return a + b;}doubleplusd(double a,double b){return a + b;}};intmain(){auto sub1 =bind(Sub, _1, _2); cout <<sub1(10,5)<< endl;// bind 本质返回的⼀个仿函数对象// 调整参数顺序（不常⽤）// _1代表第⼀个实参// _2代表第⼆个实参// ...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;// 成员函数对象进⾏绑死，就不需要每次都传递了 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;// 计算复利的lambdaauto 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;return0;}

Read more

机器学习：数据清洗与预处理 | Python

机器学习：数据清洗与预处理 | Python

个人主页-爱因斯晨 文章专栏-Python学习 文章目录 * 个人主页-爱因斯晨 * 文章专栏-Python学习 * 前言 * 了解数据清洗 * 数据清洗的步骤 * 1. 环境准备与库导入 * 2. 数据加载 * 3. 数据初探与理解 * 4. 缺失值处理 * 5. 重复值处理 * 6. 异常值处理 * 7. 数据类型转换 * 8. 数据标准化 / 归一化（预处理） * 实例实践 * 总结 前言 我们不论在学习机器学习还是数据分析中，都会涉及很多数据。但原数据不可避免有很多杂志，为了确保结果的准确性，我们需要首先进行数据清洗和预处理。 了解数据清洗 数据清洗就像是一场数据的“大扫除”。它是从原始数据中找出并修正那些错误、不完整、重复或不一致的数据。通过数据清洗，能显著提升数据质量，为后续数据分析、挖掘和建模等工作提供准确、可靠、干净的数据基础，从而让基于数据得出的结论更具可信度和价值。 数据清洗的步骤 1. 环境准备与库导入

By Ne0inhk
Python 爬虫项目实战（一）：爬取某云热歌榜歌曲

Python 爬虫项目实战（一）：爬取某云热歌榜歌曲

前言 网络爬虫（Web Crawler），也称为网页蜘蛛（Web Spider）或网页机器人（Web Bot），是一种按照既定规则自动浏览网络并提取信息的程序。爬虫的主要用途包括数据采集、网络索引、内容抓取等。 爬虫的基本原理 1. 种子 URL：爬虫从一个或多个种子 URL 开始，这些 URL 是起点。 2. 发送请求：爬虫向这些种子 URL 发送 HTTP 请求，通常是 GET 请求。 3. 获取响应：服务器返回网页的 HTML 内容作为响应。 4. 解析内容：爬虫解析 HTML 内容，提取所需的数据（如文本、链接、图片等）。 5. 提取链接：

By Ne0inhk
JAVA 泛型与通配符：从原理到实战应用

JAVA 泛型与通配符：从原理到实战应用

JAVA 泛型与通配符：从原理到实战应用 1.1 本章学习目标与重点 💡 掌握泛型的核心概念与设计初衷，理解泛型的编译期检查机制。 💡 熟练使用泛型类、泛型接口和泛型方法，解决数据类型安全问题。 💡 理解通配符（?）、上界通配符（? extends T）和下界通配符（? super T）的使用场景。 ⚠️ 本章重点是 泛型的擦除机制 和 通配符的灵活运用，这是提升代码通用性和安全性的关键。 1.2 泛型的核心概念与设计初衷 1.2.1 为什么需要泛型 在没有泛型的 JDK 5 之前，集合类只能存储 Object 类型的对象。获取元素时需要强制类型转换，这会带来两个严重问题： 1. 类型不安全：可以向集合中添加任意类型的对象，运行时可能抛出 ClassCastException。 2. 代码臃肿：频繁的强制类型转换会让代码可读性和维护性变差。 💡 泛型的出现就是为了解决这些问题，它的核心思想是

By Ne0inhk
Python 列表内存存储本质：存储差异原因与优化建议

Python 列表内存存储本质：存储差异原因与优化建议

文章目录 * 1. 问题引入：列表存储的内存 "膨胀" * 2. 理论存储与实际存储的差异 * 2.1 64位整数的存储差异 * 2.2 短字符串的存储差异 * 3. 列表的内存存储本质 * 3.1 相同元素列表内存少的核心原因：对象复用 * 3.1.1 小整数的缓存复用机制 * 3.1.2 字符串的驻留（Intern）机制 * 3.2 不同元素列表内存高的原因：对象重复创建 * 3.2.1 不同整数的内存开销 * 3.2.2 不同字符串的内存开销 * 4. 内存占用对比分析 * 5. 优化建议：利用对象复用减少内存开销 * 6. 总结

By Ne0inhk