C++11
目录
4. 可变参数模板
4.1 基本语法及原理
C++11支持可变参数模板，也就是说支持可变数量参数的函数模板和类模板，可变数目的参数被称
为参数包，存在两种参数包：模板参数包，表示零或多个模板参数；函数参数包：表示零或多个函
数参数。
- template <class ...Args> void Func(Args... args) {}
- template <class ...Args> void Func(Args&... args) {}
- template <class ...Args> void Func(Args&&... args) {}//万能引用
//没有模板语法支持
void Print(){}
void Print(int&& a){}
void Print(int &&a,int &&b){}
void Print(int&&a,int &&b,int && c){}
//有模板语法支持
//一个参数
template <class T1>
void Print( T1&&t1){}
//两个参数
template <class T1,class T2>
void Print(T1&& t1,T2&& t2){}
//三个参数
template <class T1, class T2,class T3>
void Print( T1&& t1, T2&& t2, T3 && t3){}
//可变模板参数一下搞定
template <class ...Args>
void Print(Args&&... args){}
我们用省略号来指出一个模板参数或函数参数的表示一个包，在模板参数列表中，class...或
typename...指出接下来的参数表示零或多个类型列表；在函数参数列表中，类型名后面跟...指出
接下来表示零或多个形参对象列表；函数参数包可以用左值引用或右值引用表示，跟前面普通模板
一样，每个参数实例化时遵循引用折叠规则。
double x = 2.2;
Print();
// 包里有0个参数
Print(1);
// 包里有1个参数
Print(1, string("xxxxx"));
// 包里有2个参数
Print(1.1, string("xxxxx"), x);
// 包里有3个参数
// 原理1：编译本质这里会结合引用折叠规则实例化出以下四个函数
void Print();
void Print(int&& arg1);
void Print(int&& arg1, string&& arg2);
void Print(double&& arg1, string&& arg2, double& arg3);可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。
总结：
- 函数模板，一个函数模板实例出多个相同参数个数的不同类型参数的函数
- 可变参数模板，一个可变参数模板实例化出多个不同参数个数或不同参数类型的的函数
这里我们可以使用sizeof...运算符去计算参数包中参数的个数。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//参数包表示0~n个参数
template <class ...Args>
void Print(Args&&... args)
{
cout << sizeof...(args) << endl;
//sizeof...与sizeof不一样，这是两个运算符，sizeof...计算参数包里面有几个参数
}
int main()
{
Print();//无参
Print(1);//一个参数
Print(1,2);//两个参数
Print(1,2,3);//三个参数
return 0;
}
4.2包括展
对于一个参数包，我们除了能计算他的参数个数，我们能做的唯一的事情就是扩展它，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(...)来触发扩展操作。底层的实现细节如图所示。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
void ShowList()
{
// 编译器时递归的终止条件，参数包是0个时，直接匹配这个函数
cout << endl;
}
template <class T, class ...Args>
void ShowList(T&& x, Args ...args)
{
cout << x << " ";
// args是N个参数的参数包
// 调用ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包
ShowList(args...);
}
// 编译时递归推导解析参数
template <class ...Args>
void Print(Args... args)
{
ShowList(args...);
}
int main()
{
Print();
Print(1);
Print(1, string("xxxxx"));
Print(1, string("xxxxx"), 2.2);
return 0;
}编译器一次解析一个参数，剩下的参数作为包继续递归解析
C++还支持更复杂的包扩展，直接将参数包依次展开依次作为实参给一个函数去处理。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
template <class T>
const T& GetArg(const T& x)
{
cout << x << " ";
return x;
}
template <class ...Args>
void Arguments(Args... args)
{}
template <class ...Args>
void Print(Args... args)
{
// 注意GetArg必须返回或者到的对象，这样才能组成参数包给Arguments
Arguments(GetArg(args)...);
}
// 本质可以理解为编译器编译时，包的扩展模式
// 将上面的函数模板扩展实例化为下面的函数
// 是不是很抽象，C++11以后，只能说委员会的⼤佬设计语法思维跳跃得太厉害
//void Print(int x, string y, double z)
//{
//Arguments(GetArg(x), GetArg(y), GetArg(z));
//}
int main()
{
Print(1, string("xxxxx"), 2.2);
return 0;
}实现递归打印
4.3 empalce系列接口
- template <class... Args> void emplace_back (Args&&... args);
- template <class... Args> iterator emplace (const_iterator position,Args&&... args);
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
namespace bit {
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)-构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
// 移动构造
string(string&& s)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷贝赋值" <<
endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
return *this;
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}
~string()
{
//cout << "~string() -- 析构" << endl;
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
if (_str)
{
strcpy(tmp, _str);
delete[] _str;
}
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity *
2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
}
#include<list>
// emplace_back总体而言是更⾼效，推荐以后使用emplace系列替代insert和push系列
int main()
{
list<bit::string> lt;
// 传左值，跟push_back一样，走拷⻉构造
bit::string s1("111111111111");
lt.emplace_back(s1);
lt.push_back(s1);
cout << "*********************************" << endl;
// 右值，跟push_back一样，走移动构造
lt.emplace_back(move(s1));
lt.push_back(move(s1));
cout << "*********************************" << endl;
return 0;
}传左值都是调用拷贝构造，传右值都是调用移动构造
其他容器也一样
int main()
{
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;
return 0;
}kv直接构造，模板推出kv是pair所以emplace_back()走拷贝构造，move了一下左值后变成右值，
emplance_back()走移动构造
但是传单参数就不一样了
#include<list>
// emplace_back总体而言是更⾼效，推荐以后使用emplace系列替代insert和push系列
int main()
{
list<bit::string> lt;
// 直接把构造string参数包往下传，直接用string参数包构造string
// 这里达到的效果是push_back做不到的
lt.emplace_back("111111111111"); //隐式类型转换后直接移动构造
lt.push_back("11111111111111");//直接传参，走隐式类型转换
cout << "*********************************" << endl;
return 0;
}emplace_back（）走的是直接构造+构造，而push_back（）走的是构造+移动构造，这是为什么呢？
因为push_back（）里面的value_type&& 是个确定的bit::string已经实例化了右值引用引用的是中间的临时对象（“11111111”隐式类型转化而来的），隐式类型转换是一次构造，push_back是移动构造 所以是构造+移动构造；而Arges包并没有确定是什么类型，可变参数模板没有实例化，模板根据“11111”推出Arges是const char* 右引传右引，往下传就是直接构造，再加上本身隐式类型转换就是构造+构造
同理，类似的其他容器也是
#include<list>
// emplace_back总体而言是更⾼效，推荐以后使用emplace系列替代insert和push系列
int main()
{
list<pair<bit::string, int>> lt1;
lt1.emplace_back("苹果", 1 );
cout << "*********************************" << endl;
// 跟push_back⼀样
lt1.push_back({ "苹果", 1 });
cout << "*********************************" << endl;
return 0;
}
emplace_back不支持隐式类型转换，模板不知道该匹配什么类型，但是可以把多参数往下传，包解析会完成实例化构造。而push_back只支持隐式类型转换，传多参数会报错
总结：emplace系列兼容push系列和insert的功能，部分场景下emplace可以直接构造，push和insert是 构造+移动构造或构造+拷贝构造 所以emplace综合更强大，更好用，推荐使用emplace系列代替push和insert
第二个程序中我们模拟实现了list的emplace和emplace_back接口，这里把参数包不断往下传递，
最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前面说的empalce支持
直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
传递参数包过程中，如果是 Args&&... args 的参数包，要用完美转发参数包，方式如下
std::forward<Args>(args)... ，否则编译时包扩展后右值引用变量表达式就变成了左值。
template <class... Args>
void emplace_back(Args&&... args)
{
insert(end(), std::forward<Args>(args)...);
}
template <class... Args>
iterator insert(iterator pos, Args&&... args)
{
Node* cur = pos._node;
Node* newnode = new Node(std::forward<Args>(args)...);
Node* prev = cur->_prev;
// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
}5. 新的类功能
5.1 默认的移动构造和移动赋值
原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址重
载/const 取地址重载，最后重要的是前4个，后两个用处不大，默认成员函数就是我们不写编译器
会生成一个默认的。C++11 新增了两个默认成员函数，移动构造函数和移动赋值运算符重载。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;
namespace bit
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)-构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
// 移动构造
string(string&& s)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷贝赋值" <<
endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
return *this;
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}
~string()
{
//cout << "~string() -- 析构" << endl;
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
if (_str)
{
strcpy(tmp, _str);
delete[] _str;
}
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity *
2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
private:
char* _str = new char('\0');
size_t _size = 0;
size_t _capacity = 0;
};
}
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:
bit::string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
Person s4;
s4 = std::move(s2);
return 0;
}
如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一
个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执
行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调自
移动构造，没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
没有析构和移动赋值下调用拷贝构造
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
没提供移动赋值的情况：左值调用构造和拷贝构造，右值调用拷贝赋值
移动构造或者移动赋值都没有：左值调用拷贝构造，右值调用拷贝赋值
5.2.声明给缺省值
参照以往博客
5.3 defult和delete
- C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。
- 如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
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;
//Person(const Person& p) = delete;
private:
bit::string _name;
int _age;
};
5.4 final 与 overator
参照以往博客
6.STL中一些变化
下图圈起来的就是STL中的新容器，但是实际最有用的是unordered_map和unordered_set。
STL中容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列
接口和移动构造和移动赋值，还有initializer_list版本的构造等，还有一些无关痛痒的需要时查查文档即可容器的范围for遍历
7. lambda
7.1 lambda表达式语法
lambda表达式的格式：
[capture-list] (parameters)-> return type {function boby }
[ 捕捉列表 ] ( 参数列表 )-> 返回值类型 { 函数体 }
- lambda 表达式本质是一个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。lambda 表达式语法使用层而言没有类型，所以我们一般是用auto或者模板参数定义的对象去接收 lambda 对象。
- [capture-list] : 捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据[]来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用，捕捉列表可以传值和传引用捕捉，具体细节7.2中我们再细讲。捕捉列表为空也不能省略。
- (parameters) ：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同()⼀起省略
- ->return type ：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。一般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
- {function boby} ：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
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 bit" << 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;
}
7.2 捕捉列表
lambda 表达式中默认只能用 lambda 函数体和参数中的变量，如果想用外层作用域中的变量就
需要进行捕捉
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int x = 0;
// 捕捉列表为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量
auto func1 = []()
{
x++;//可用
//a++;//不可用
//b++ //不可用
};
int main()
{
int a=0, int b=1;
return 0;
}第一种捕捉方式是在捕捉列表中显示的传值捕捉和传引用捕捉，捕捉的多个变量用逗号分割。[x，y， &z] 表示x和y值捕捉，z引用捕捉。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main()
{ int x = 0;
int y = 0 ;
int i = 0;
int& z = x;
auto fun2 = [x,y,&z,d ](int q) //报错，d的声明在lambda下面，d的函数栈帧在lambda下面，编译器只会向上找不会向下找，找不到d的声明就会报标识符错误
{
//捕捉列表内值捕捉的变量不能修改，引用变量的就可以
x++;//报错
y++;//报错
z++;//可以执行
i++;//没捕捉的变量不可以使用
q++;//可以执行，
};
int d = 0;
auto func3 = [x,&x]() {};//报错，同一个变量不能捕捉两次
return 0;
}
第二种捕捉方式是在捕捉列表中隐式捕捉，我们在捕捉列表写一个=表示隐式值捕捉，在捕捉列表
写一个&表示隐式引用捕捉，这样我们 lambda 表达式中用了那些变量，编译器就会自动捕捉那些
变量。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main()
{ int x = 0;
int y = 0 ;
int i = 0;
int d = 0;
//自由捕捉
//想捕哪个就捕哪个
auto func0 = [&x,y]() {};
//隐式值捕捉
//用了哪些变量就捕捉哪些
auto func1 = [=]() {};
//隐式引用捕捉
//用了哪些变量就捕捉哪些
auto func2 = [&]() {};
return 0;
}
第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显示捕捉。[=, &x]表示其他变量隐式值捕捉，x引用捕捉；[&, x, y]表示其他变量引用捕捉，x和y值捕捉。当使用混合捕捉时，第⼀个元素必须是
&或=，并且&混合捕捉时，后面的捕捉变量必须是值捕捉，同理=混合捕捉时，后面的捕捉变量必
须是引用捕捉。
//混合捕捉
//原则上混合捕捉支持值捕捉和引用捕捉混合使用
auto fun3 = [&,x,y]() {};
auto func4 = [=,&x,&y]() {};
lambda 表达式如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态
局部变量和全局变量，静态局部变量和全局变量也不需要捕捉， lambda 表达式中可以直接使用。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
#include<iostream>
// 捕捉列表为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量
int a=0;
auto func1 = []()
{
a++;//可用
};
int main()
{
return 0;
}
默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改，
mutable加在参数列表的后面可以取消其常量性，也就说使用该修饰符后，传值捕捉的对象就可以
修改了，但是修改还是形参对象，不会影响实参。使⽤该修饰符后，参数列表不可省略(即使参数为空)。
#include<iostream>
int main()
{ int x = 0;
int y = 0 ;
int& i = y;
auto fun=[x,&i]() mutable
{
++ x;
++ i;
int ret = x + i;
cout << ret << endl;
cout << "x: " << x << " " << "i: " << i << endl;
};
fun();
cout << "x: " << x << " " << "i: " << i << endl;
return 0;
}mutable修饰后，在fun函数里面捕捉列表里的值捕捉可以修改，但是出了函数后值恢复到没修改前，但是引用捕捉的是是引用，引用的本质就是指针，指向的内容被修改了，即便是出了函数，依旧不能复原
7.3 lambda的应用
- 在学习 lambda 表达式之前，我们的使用的可调用对象只有函数指针和仿函数对象，函数指针的类型定义起来比较麻烦，仿函数要定义一个类，相对会比较麻烦。使用 lambda 去定义可调用对象，既简单又方便。
- lambda 在很多其他地方用起来也很好用。比如线程中定义线程的执行函数逻辑，智能指针中定制删除器等， lambda 的应用还是很广泛的，以后我们会不断接触到。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<assert.h>
#include <algorithm>
using namespace std;
struct Goods
{
string _name; //名字
double _price; //价格
int _evaluate; //评价
Goods(const char* str, double price, int evaluate)
:_name(str)
,_price(price)
,_evaluate(evaluate)
{}
};
struct ComparePriceLess1
{
bool operator()(const Goods& g1,const Goods& gr)
{
return g1._price < gr._price;
}
};
struct ComparePriceLess2
{
bool operator()(const Goods& g1, const Goods& gr)
{
return g1._price < gr._price;
}
};
int main()
{
vector<Goods> v = { {"苹果",2.1,5},{"香蕉",3,4},{"橙子",2.2,3},{"菠萝",1.1,2} };
//价格升序
sort(v.begin(),v.end(), ComparePriceLess1());
//价格降序
sort(v.begin(), v.end(), ComparePriceLess2());
return 0;
}int main()
{
vector<Goods> v = { {"苹果",2.1,5},{"香蕉",3,4},{"橙子",2.2,3},{"菠萝",1.1,2} };
//评价升序
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;
}7.4 lambda的原理
- lambda 的原理和范围for很像，编译后从汇编指令层的角度看，压根就没有 lambda 和范围for这样的东西。范围for底层是迭代器，而lambda底层是仿函数对象，也就说我们写了一个lambda 以后，编译器会生成一个对应的仿函数的类。
- 仿函数的类名是编译按⼀定规则生成的，保证不同的 lambda 生成的类名不同，lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是生成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使用哪些就传那些对象。
- 上面的原理，我们可以透过汇编层了解⼀下，下面第二段汇编层代码印证了上面的原理。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
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;
// lambda
auto 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();
return 0;
}
// lambda
auto 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,8
00D8296B 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
2
00D8297F sub
esp,8
00D82982 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
2
00D8299B sub
esp,8
00D8299E 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)8. 包装器
8.1 function
template <class T>
class function;
// undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;std::function 是一个类模板，也是一个包装器。 std::function 的实例对象可以包装存储其他的可以调用对象，包括函数指针、仿函数、 lambda 、 bind 表达式等，存储的可调用对象被称为std::function 的目标。若 std::function 不含目标，则称它为空。调用空std::function 的目标导致抛出 std::bad_function_call 异常。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;
#include<functional>
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()
{
// 包装各种可调用对象
function<int(int, int)> f1 = f; //函数
function<int(int, int)> f2 = Functor(); //仿函数
function<int(int, int)> f3 = [](int a, int b) {return a + b; }; //lambda
cout << f1(1, 1) << endl;
cout << f2(1, 1) << endl;
cout << f3(1, 1) << endl;
// 包装静态成员函数
// 成员函数要指定类域并且前面加&才能获取地址，并且静态成员函数没有this指针
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;//匿名对象属于右值
return 0;
}
以上是 function 的原型，他被定义<functional>头文件中。std::function - cppreference.com
是function的官方文件链接。
函数指针、仿函数、 lambda 等可调用对象的类型各不相同， std::function 的优势就是统一类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型，下面的第而个代码样例展示了 std::function 作为map的参数，实现字符串和可调用对象的映射表功能。
#include<iostream>
#include<stack>
#include<vector>
#include <string>
#include <map>
using namespace std;
// 传统⽅式的实现
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;
// function作为map的映射可调⽤对象的类型
map<string, function<int(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();
}
};8.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 也在<functional>这个头文件中。
- 调用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的一个命名空间中。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
#include<functional>
using namespace std;
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int Sub(int a, int b)
{
return (a - b) * 10;
}
int SubX(int a, int b, int c)
{
return (a - b - c) * 10;
}
int main()
{
//调整参数顺序
//_1表示第一个实参，_2表示第二个实参
auto sub1 = bind(Sub, _1, _2);
cout << sub1(10, 5) << endl;
auto sub2f = bind(Sub, _2, _1);
cout << sub1(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;
return 0;
}计算复利
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
#include<functional>
using namespace std;
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int main()
{
// 计算复利的lambda
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;
};
// 绑死⼀些参数，实现出⽀持不同年华利率，不同⾦额和不同年份计算出复利的结算利息
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;
return 0;
}原文地址：https://blog.csdn.net/2302_81171591/article/details/143659402
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！