C++11
一、 C++11简介
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。
从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。C++11增加的语法特性非常篇幅非常多，我们这里没办法一 一讲解，所以本节课程主要讲解实际中比较实用的语法。
https://en.cppreference.com/w/cpp/11
小故事：
1998年是C++标准委员会成立的第一年，本来计划以后每5年视实际需要更新一次标准，C++国际标准委员会在研究C++ 03的下一个版本的时候，一开始计划是2007年发布，所以最初这个标准叫C++ 07。但是到06年的时候，官方觉得2007年肯定完不成C++ 07，而且官方觉得2008年可能也完不成。最后干脆叫C++ 0x。x的意思是不知道到底能在07还是08还是09年完成。结果2010年的时候也没完成，最后在2011年终于完成了C++标准。所以最终定名为C++11。
二、 统一的列表初始化
2.1 ｛｝初始化
在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：
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;
}
但是对于一些自定义类型，却无法使用这样的初始化。
vector<int> v{1,2,3,4,5};
像这样的自定义类型就无法使用初始化列表去初始化，从而导致无法通过编译，因此每次定义vector时，都需要先把vector定义出来，然后使用循环对其赋值初始值，非常不方便。
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。
内置类型的列表初始化
int main()
{
//内置类型变量
int a = 1;
int b = { 2 };
int c{ 3 };
int arr1[]{1, 2, 3, 4, 5};
int arr2[5]{0};
//动态数组，在C++98中不支持
int* arr3 = new int[5]{1, 2, 3, 4, 5};
//标准容器
vector<int> v{1,2,3,4,5};//这种初始化就变得很方便，不需要我们创建了一个对象之后再去一个个的插入了
map<int,int> m{{1,1},{2,2},{3,3},{4,4}};
return 0;
}
注意： 列表初始化可以在{}之前使用等号，其效果与不使用=没有什么区别，但是为了代码的可读性建议加上=。
自定义类型的列表初始化
- 标准库支持单个对象的列表初始化
struct Point
{
//explicit Point(int x, int y)//加上explicit就不能用多参数的隐式类型转换
Point(int x, int y)
:_x(x)
,_y(y)
{
cout << "Point(int x, int y)" << endl;
}
int _x;
int _y;
};
int main()
{
//本质都是调用构造函数
Point p0(0, 0);
Point p1 = { 1,1 };//多参数构造函数隐式类型转换，本质是先构造出来一个Point再拷贝构造给p1（加上explicit就不支持多参数构造函数隐式类型转换）
Point p2 { 2,2 };
const Point& r = { 3,3 };//引用赋值的话由于类型转换都要生成临时对象，而临时对象具有常性，所以这里要加上const变成常量引用，防止r对其进行修改
//动态数组，在C++98中不支持
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;
}
注意：一切皆可以用{}初始化，并且可以不写=，建议日常定义，不要去掉=，但是我们要能看懂
多个对象的列表初始化
多个对象想要支持列表初始化，需要给该类(模板类) 添加一个带有initializer_list类型参数的构造函数即可
2.2 std::initializer_list
std::initializer_list的介绍文档：
http://www.cplusplus.com/reference/initializer_list/initializer_list/
std::initializer_list是什么类型：
int main()
{
// the type of il is an initializer_list
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
return 0;
}
运行结果：
std::initializer_list使用场景：
std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加
std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。
- list：
http://www.cplusplus.com/reference/list/list/list/
- vector:
http://www.cplusplus.com/reference/vector/vector/vector/ - map:
http://www.cplusplus.com/reference/map/map/map/ - vector::operator=
http://www.cplusplus.com/reference/vector/vector/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;
}
下面我们来模拟一个initializer_list类型作为参数的构造函数和赋值重载
template<class T>
class Vector
{
public:
Vector(initializer_list<T> l)
:_size(0)
,_capacity(l.size())
{
_a = new T[_capacity];
for (auto e : l)
{
_a[_size++] = e;
}
}
Vector<T>& operator=(initializer_list<T> l)
{
delete _a;
_size = 0;
_capacity = l.size();
_a = new T[_capacity];
for (auto e : l)
{
_a[_size++] = e;
}
return *this;
}
private:
T* _a;
size_t _size;
size_t _capacity;
};
运行示例：
int main()
{
// 不同的规则
vector<int> v1 = { 1,2,3,4,3}; // 调用initializer_list的vector构造函数
Point p1 = { 1,1}; // 直接调用两个参数的构造 -- 隐式类型转换
auto il = { 10, 20, 30 };
//initializer_list<int> il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
cout << sizeof(il) << endl;
bit::vector<int> v2 = { 1,2,3,4,54};//在自定义的vector中加上initializer_list参数类型的构造就可以运行了
for (auto e : v2)
{
cout << e << " ";
}
cout << endl;
// 这里{"sort", "排序"}会先初始化构造一个pair对象
map<string, string> dict = { {"sort", "排序"}, {"left", "左边"} };
return 0;
}
三、声明（变量类型推导）
c++11提供了多种简化声明的方式，尤其是在使用模板时。
变量类型推导
为什么需要类型推导？
在定义变量时，必须先给出变量的实际类型，编译器才允许定义，但有些情况下可能不知道需要实际类型该怎么给，或者类型写起来特别复杂。
如：
std::map<std::string, std::string>m{ { "sort", "排序" }, { "apple", "苹果" }};
//使用迭代器遍历容器，迭代器类型太繁琐
std::map<std::string, std::string>::iterator it = m.begin();
在C++11中，可以使用auto来根据变量初始化表达式类型去推导变量的实际类型，可以给程序的书写提供许多方便，将程序中的c与it的类型换成auto，程序可以通过编译，而且更加的简洁。
3.1 auto
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃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;
}
3.2 decltype
auto使用的前提是：必须要对auto声明的类型进行初始化，否则编译器无法推导出auto的实际类型。 但有时候可能需要根据表达式运行完成之后结果的类型进行推导，因为编译期间，代码不会允许，此时auto也就无能为力。
关键字decltype将变量的类型声明为表达式指定的类型。
decltype使用场景：
- decltype推出对象的类型，再定义变量，或者作为模板实参
- 单纯先定义一个变量出现
// decltype的一些使用使用场景
class A
{
private:
decltype(malloc) pf2;
};
template<class Func>
class B
{
private:
Func _f;
};
int main()
{
int i = 10;
auto p = &i;
auto pf = malloc;
//auto x;
cout << typeid(p).name() << endl;
cout << typeid(pf).name() << endl;
// typeid(pf).name() ptr; typeid推出类型是一个字符串，只能看不能用
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;
}
3.3 nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
void func(int x)
{
cout << "NULL" << endl;
}
void func(int* p)
{
cout << "nullptr" << endl;
}
//const enum inline去替代宏
int main()
{
int* p = NULL; // int* p = 0;
int* p1 = nullptr; // int* p = 0;
func(NULL); // func(0);
func(p1);
return 0;
}
3.4final与override
3.4.1final
- final修饰一个类的时候，表示该类不能被继承
//被final修饰的类我们一般叫做最终类，无法被继承
class A final
{
private:
int _a;
};
//无法继承
class B :public A
{
//...
};
- final修饰虚函数时，这个虚函数不能被重写
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() { cout << "Benz-舒适" << endl; }
};
override
override用来检查派生类是否重写了基类某个虚函数，如果没有重写编译报错
- 完成了重写：
class A
{
public:
virtual void fun()
{
cout << "A::fun()" << endl;
}
private:
int _a;
};
class B : public A
{
public:
//override：检查派生类虚函数是否重写了基类中的某个虚函数，如果没有重写就编译报错
virtual void fun()override
{
cout << "B::fun()" << endl;
}
};
- 未完成重写：
class A
{
public:
virtual void fun()
{
cout << "A::fun()" << endl;
}
private:
int _a;
};
class B : public A
{
public:
//override：检查派生类虚函数是否重写了基类中的某个虚函数，如果没有重写就编译报错
virtual void fun(int )override
{
cout << "B::fun()" << endl;
}
};
四、STL中一些变化
新容器
用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和
unordered_set。这两个我们前面已经进行了非常详细的讲解，其他的大家了解一下即可。
容器中的一些新方法
如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。
比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。
实际上C++11更新后，容器中增加的新方法最后用的插入接口函数的右值引用版本：
http://www.cplusplus.com/reference/vector/vector/emplace_back/
http://www.cplusplus.com/reference/vector/vector/push_back/
http://www.cplusplus.com/reference/map/map/insert/
http://www.cplusplus.com/reference/map/map/emplace/
但是这些接口到底意义在哪？网上都说他们能提高效率，他们是如何提高效率的？
请看下面的右值引用和移动语义章节的讲解。另外emplace还涉及模板的可变参数，也需要再继续深入学习后面章节的知识。
五、右值引用和移动语义
5.1 左值引用和右值引用
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。**无论左值引用还是右值引用，都是给对象取别名。**引用变量与引用实体公用同一块内存空间。
1.什么是左值？什么是左值引用？
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。在定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
2.什么是右值？什么是右值引用？
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
int fmin(int a, int b)
{
return a < b ? a : b;
}
int main()
{
//const int a = 10;
//int b = a;
a = 20;
// 以下的ptr、b、c、*p都是左值
int* ptr = new int(0);
int b = 1;
const int c = 2;
"xxxxx";
const char* p = "xxxxx";
p[2];
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10;
x + y;//这个表达式的结果是一个临时值,这个表达式被评估后，它就会被丢弃。因此，它是一个右值。
fmin(x, y);//这个函数返回值也是一个临时值，并且在这个表达式被评估后，它就会被丢弃。因此，它也是一个右值。
// cout << &10 << endl;
// cout << &(x+y)<< endl;
// cout << &(fmin(x, y)) << endl;
cout << &("xxxxx") << endl;
cout << &p[2] << endl;
return 0;
}
需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。
int main()
{
double x = 1.1, y = 2.2;
int&& rr1 = 10;
const double&& rr2 = x + y;
rr1 = 20;
rr2 = 5.5; // 报错
return 0;
}
5.2 左值引用与右值引用比较
左值引用总结：
- 左值引用只能引用左值，不能引用右值。
- 但是const左值引用既可引用左值，也可引用右值。
右值引用总结：
- 右值引用只能右值，不能引用左值。
- 但是右值引用可以move以后的左值。
//左值引用 右值引用
//引用是取别名
//左值引用:给左值取别名
//右值引用:给右值取别名
int main()
{
double x = 1.1, y = 2.2;
// 左值引用:给左值取别名
int a = 0;
int& r1 = a;
// 左值引用能否给右值取别名？
// const左值引用可以
const int& r2 = 10;
const double& r3 = x + y;
// 右值引用:给右值取别名
int&& r5 = 10;
double&& r6 = x + y;
// 右值引用能否给左值取别名？
// 右值引用可以引用move以后的左值
int&& r7 = move(a);
return 0;
}
5.3 右值引用使用场景和意义
前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！
namespace bit
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
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);
}
// s1.swap(s2)
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;
string tmp(s._str);
swap(tmp);
}
string(string&& s)
:_str(nullptr)
{
cout << "string(string&& s) -- 移动拷贝" << endl;
swap(s);
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
string& operator=(string&& s)
{
cout << "string& operator=(string && s) -- 移动拷贝" << endl;
swap(s);
return *this;
}
~string()
{
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];
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)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
bit::string to_string(int value)
{
bit::string str;
while (value)
{
int val = value % 10;
str += ('0' + val);
value /= 10;
}
reverse(str.begin(),str.end());
return str;
}
}
左值引用的使用场景：
做参数和做返回值都可以提高效率。
void func1(bit::string s)
{}
void func2(const bit::string& s)
{}
int main()
{
bit::string s1("hello world");
// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
func1(s1);
func2(s1);
// string operator+=(char ch) 传值返回存在深拷贝
// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
s1 += '!';
return 0;
}
左值引用的短板：
当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
bit::string to_string(int value)
{
bit::string str;
while (value)
{
int val = value % 10;
str += ('0' + val);
value /= 10;
}
reverse(str.begin(),str.end());
return str;
}
int main()
{
//不能使用左值引用返回，这个就是左值引用的一个短板
//函数返回对象出了作用域就不在了，因此不能用左值引用返回（因为返回的是本身地址，栈帧已销毁）
//所以会存在拷贝问题
bit::string ret = bit::to_string(1234);
return 0;
}
下面我们一起来分析一下左值引用的短板以及如何使用右值引用来解决的
to_string是一个传值返回的函数，它最后返回的并不是str，返回的是str的拷贝，str会先拷贝构造一个临时对象（这里会发生一次深拷贝），然后再将临时对象拷贝构造给ret（这里会再发送一次拷贝构造），连续的两次构造会被编译器优化成一次，因为我们这里只会看到一次拷贝构造
下面来分析一下上面传值返回的问题：
传值返回的to_string函数正常返回时，需要用str构造一个临时对象，临时对象和str中的内容完全相同，出来函数作用域后，str就被销毁掉了，这个过程经历了——刚申请一段空间，又是一段相同大小的空间，这对于资源无疑是一种很大的浪费
那么针对上面传值返回的问题，我们如何通过右值引用来解决呢？
我们可以通过在string类里面提供一个移动构造的成员函数来解决上面的问题
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动拷贝" << endl;
this->swap(s);
}
注意：右值又分为纯右值和将亡值
- 纯右值：10、a+b
- 将亡值：函数返回的临时对象、匿名对象
加入移动构造后运行结果：
除了移动构造外，我们还可以增加移动赋值在某些场景下来提高效率
右值引用和移动语义解决上述问题：
- 传值返回的to_string函数正常返回时，需要用str构造一个临时对象，临时对象和str中的内容完全相同，出来函数作用域后，str就被销毁掉了，这个过程经历了——刚申请一段空间，又是一段相同大小的空间，这对于资源无疑是一种很大的浪费。
- 在bit::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。
再运行上面bit::to_string的两个调用，我们会发现，这里没有调用深拷贝的拷贝构造，而是调用了移动构造，移动构造中没有新开空间，拷贝数据，所以效率提高了。
当我们将str的这个将亡值的资源通过移动构造转移到临时对象身上之后，我们可以将临时对象的资源转移到ret身上，也就不需要再去调用赋值运算符重载，而是调用移动赋值，这样就会减少深拷贝，从而由一次移动构造+两次深拷贝变成了一次移动构造+一次移动赋值
不仅仅有移动构造，还有移动赋值：
下面我们来看一下移动赋值的使用场景：
int main()
{
bit::string ret1;
ret1 = bit::to_string(1234);
return 0;
}
可以看到当代码里面如果没有移动赋值时，我们这里就是一次移动构造加上两次深拷贝，大家可能会有点疑问为什么会有两次深拷贝呢？因为我们的赋值重载是现代写法，里面会调用拷贝构造，因此就会出现两次深拷贝。
下面我们来对这段代码进行分析一下：
to_string函数它是传值返回的，我们知道传值返回的函数的返回值是一个将亡值，因为我们这里有移动构造，那么就会将这个返回的str识别成将亡值（右值），然后将它的资源转移到临时对象身上，再调用赋值重载将这个临时对象的值赋给ret，调用赋值重载需要两次深拷贝（现代写法复用了拷贝构造），这样的代价是很大的。
那我们如何通过移动赋值来解决上面的问题呢？
当我们将str的这个将亡值的资源通过移动构造转移到临时对象身上之后，我们可以将临时对象的资源转移到ret身上，也就不需要再去调用赋值运算符重载，而是调用移动赋值，这样就会减少深拷贝，从而由一次移动构造+两次深拷贝变成了一次移动构造+一次移动赋值
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}
int main()
{
bit::string ret1;
ret1 = bit::to_string(1234);
return 0;
}
运行结果：
这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。bit::to_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为bit::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。
STL中的容器都是增加了移动构造和移动赋值：
http://www.cplusplus.com/reference/string/string/string/
http://www.cplusplus.com/reference/vector/vector/vector/
5.4 右值引用引用左值及其一些更深入的使用场景分析
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
return ((typename remove_reference<_Ty>::type&&)_Arg);
}
int main()
{
bit::string s1("hello world");
// 这里s1是左值，调用的是拷贝构造
bit::string s2(s1);
// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
// 资源被转移给了s3，s1被置空了。
bit::string s3(std::move(s1));
return 0;
}
STL容器插入接口函数也增加了右值引用版本：
http://www.cplusplus.com/reference/list/list/push_back/
http://www.cplusplus.com/reference/vector/vector/push_back/
void push_back (value_type&& val);
int main()
{
list<bit::string> lt;
bit::string s1("1111");
// 这里调用的是拷贝构造
lt.push_back(s1);
// 下面调用都是移动构造
lt.push_back("2222");
lt.push_back(std::move(s1));
return 0;
}
运行结果：
// string(const string& s) -- 深拷贝
// string(string&& s) -- 移动语义
// string(string&& s) -- 移动语义
总结：
左值引用的核心价值就是减少拷贝，提高效率
右值引用出来以后，并不是直接使用右值引用去减少拷贝，提高效率。而是支持深拷贝的类，提供移动构造和移动赋值 ，这时这些类的对象进行传值返回或者是参数为右值时，则可以用移动构造和移动赋值，转移资源，避免深拷贝，提高效率。
场景一：
场景二：容器的插入接口，如果插入对象是右值，可以利用移动构造转移资源给数据结构中的对象。也可以减少。
int main()
{
//这里s1是左值，代表的是字符串的首元素地址
list<bit::string> lt;
bit::string s1("111111111111111111111");
lt.push_back(s1);
cout << endl << endl;
//这里move会返回一个右值，可以进行移动构造，减少拷贝
bit::string s2("111111111111111111111");
lt.push_back(move(s2));
//单参数的构造隐式类型转换要构造一个匿名对象，而匿名对象是一个将亡值，属于右值 ，可以进行移动构造，减少拷贝
cout << endl << endl;
lt.push_back("22222222222222222222222222222");
return 0;
}
5.5 完美转发
5.5.1模板中的&& 万能引用
完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。
void Func(int x)
{
//...
}
template<typename T>
void PerfectForward(T t)
{
Func(t);
}
PerfectForward为转发的模板函数，Func为实际目标函数， 但是上述转发还不算完美， 完美转发是目标函数总希望将参数按照传递给转发函数的实际类型转给目标函数，而不产生额外的开销， 就好像转发者不存在一样。
所谓完美： 函数模板在向其他函数传递自身形参时，如果相应实参是左值，它就应该被转发为左值；如果相应实参是右值，它就应该被转发为右值。 这样做是为了保留在其他函数针对转发而来的参数的左右值属性进行不同处理（比如参数为左值时实施拷贝语义；参数为右值时实施移动语义）
先了解一些万能引用：
- 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
- 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力
- 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值
- 我们希望能够在传递过程中保持它的左值或者右值的属性,就需要用我们下面学习的完美转发。
下面我们先来看一段代码：
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); // const 左值
PerfectForward(std::move(b)); // const 右值
return 0;
}
运行结果：
看到这个运行结果之后大家心里面可能会有点疑惑：你刚刚上面自己说万能引用既可以接受左值也可以接受右值，那为什么这里万能引用接受了右值之后再去调用Fun函数，调用的却是左值引用或者const左值引用的Fun函数呢？
不知道大家是否还记得我们在前面说过右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址。 因此右值引用的对象，再作为实参传递时它的属性会退化成左值，因此只能匹配左值引用的Fun函数。
5.5.2 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)
{
// 完美转发，t是左值引用，保持左值属性
// 完美转发，t是右值引用，保持右值属性
Fun(forward<T>(t));
}
int main()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
return 0;
}
运行结果：
可以看到我们使用了完美转发之后，左值就匹配左值引用的Fun函数，右值就匹配右值引用的Fun函数，达到了我们想要的结果。
右值引用变量被识别为左值的一些场景：
void PerfectForward(int&& t)
{
Fun(t);
}
int main()
{
PerfectForward(10); // 右值
int a;
//PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
//PerfectForward(b); // const 左值
//PerfectForward(std::move(b)); // const 右值
//引用的底层是指针，这里左值引用和右值引用的地址是相同的，说明右值引用的属性是左值，右值引用一定要支持修改！
int& r = a;
int&& rr = move(a);
cout << &r << endl;
cout << &rr << endl;
// 右值不能取地址，右值也不能修改
rr++;
//这里rrr是右值，相当于开辟了一块空间将10存进去
int&& rrr = 10;
rrr++;
cout << &rrr << endl;
return 0;
}
完美转发实际中的使用场景：
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;
};
int main()
{
List<bit::string> lt;
lt.PushBack("1111");
lt.PushFront("2222");
return 0;
}
六、新的类功能
默认成员函数
原来C++类中，有6个默认成员函数：
- 构造函数
- 析构函数
- 拷贝构造函数
- 拷贝赋值重载
- 取地址重载
- const 取地址重载
最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。
C++11 新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
- 如果你没有自己实现移动构造函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝（浅拷贝），自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
- 如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
- 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
（如果需要自己提供析构函数，说明发生了深拷贝，就需要自己提供拷贝构造或者拷贝赋值重载）
下面我们用自己简单模拟实现的string在VS2019环境下进行演示。我们用Person类有析构函数和没有析构函数，两种情况下，使用右值构造一个对象、使用右值对象给另一个对象进行赋值，看看会调用哪个函数。
有析构函数：
namespace bit
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
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);
}
// s1.swap(s2)
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;
string tmp(s._str);
swap(tmp);
}
string(string&& s)
:_str(nullptr)
{
cout << "string(string&& s) -- 移动拷贝" << endl;
swap(s);
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
string& operator=(string&& s)
{
cout << "string& operator=(string && s) -- 移动赋值" << endl;
swap(s);
return *this;
}
~string()
{
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];
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)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
bit::string to_string(int value)
{
bit::string str;
while (value)
{
int val = value % 10;
str += ('0' + val);
value /= 10;
}
reverse(str.begin(), str.end());
return str;
}
}
class Person
{
public:
Person(const char* name = "小李", int age = 0)
:_name(name)
, _age(age)
{}
~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;
}
运行结果：
这里赋值重载用的是现代写法，所以最后又调用了一次深拷贝。
可以看到，在类person中提供了析构函数，编译器就自己提供了默认的移动构造和移动赋值，对自定义类型调用自己的深拷贝。
接下来看看没有析构函数的情况：
class Person
{
public:
Person(const char* name = "小李", int age = 0)
:_name(name)
, _age(age)
{}
//~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;
}
运行结果：
可以看到，在类person中没有提供析构函数和拷贝构造、拷贝赋值重载，编译器对自定义类型调用了它自己的移动拷贝和移动赋值。
通过上面的运行结果我们可以看到，编译器生成默认的移动构造和移动赋值的条件还是很苛刻的。
七、可变模板参数
C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模板和函数模板中只能含固定数量的模板参数，可变模板参数无疑是一个巨大的改进。
下面就是一个基本可变参数的函数模板
//Args是一个模板参数包，args是一个函数形参参数包
//声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数
template<class...Args>
void ShowList(Args... args)
{}
上面的参数Args前面有省略号，所以它就是一个可变模板参数，我们把带省略号的参数称为参数包，它里面包含了0到N（N>=0）个模板参数。我们无法直接获取参数包Args中的每个参数，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模板参数的一个主要特点，也是最大的难点，即如何展开可变模板参数。
//可变参数，你传int，char，还是自定义类型都会自动给你推导
//可以包含0 - 任意个参数
template<class ...Args>
void ShowList(Args... args)
{
cout << sizeof...(args) << endl;//计算参数包的个数
}
int main()
{
ShowList(1);
ShowList(1, 'a');
ShowList(1, 'z', string("sort"));
ShowList(1, 'a', 'A',string("sort"));
return 0;
}
运行结果：
下面我们介绍两种方法来展开可变模板参数：
- 递归函数方式展开参数包
递归调用ShowList，当参数包中的参数个数为0时，调用递归终止函数，args中第一个参数作为value传参，参数包中剩下的参数作为新的参数包传参，如此我们便拿到了参数包里面的所有参数
//递归函数方式展开参数包
// 递归终止函数
//参数包剩下最后一个参数调用这个重载函数
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;
}
运行结果：
上面这种写法有些人可能觉得有点复杂了，因为每一次展开模板参数，我们都需要用第一个参数val去推，那有没有什么办法不用第一个参数去推并且也能展开模板参数呢，下面我们来介绍第二种方法。
- 逗号表达式展开参数包
如果一个参数包中的参数都是同一类型，那么可以使用该参数包对数组进行列表初始化，参数包会进行展开，如何对数组进行初始化。
template<class...Args>
void ShowList(Args...args)
{
int arr[] = { args... };
cout << endl;
}
int main()
{
ShowList(1, 2, 3);
return 0;
}
那如果参数包里面的参数不是同一类型的我们应该如何去做呢？我们可以在使用列表初始化数组时，展开参数包的特性，再与一个逗号表达式结合使用，既展开了参数包又对数组进行了初始化。
template<class T>
void PrintArg(T val)
{
cout << typeid(T).name() << ":" << val << endl;
}
//展开函数
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;
}
运行结果：
八、STL容器中的empalce相关接口函数
学习了可变模板参数参数与右值引用之后，下面我们再来了解一下STL容器里面的emplace_back系列接口，并且对比一下push_back接口
http://www.cplusplus.com/reference/vector/vector/emplace_back/
注意：这里的&&不是右值引用而是万能引用，如果实参是左值，那么参数包的形参就是左值引用，如果实参是右值，那么参数包的形参就是右值引用。
下面我们先来看一下push_back与emplace_back 的用法上面有没有上面区别
可以看到push_back与emplace_back在用法上其实没什么区别，可以说基本上用法是一样的。
只不过emplace_back支持可变参数包，然后调用定位new，使用参数包对空间进行初始化，即支持下面这种
mylist.emplace_back(1, 'A');
push_back虽然不支持这种方式初始化，但是它可以使用初始化列表来进行类似的操作，但是emplace_back不能使用初始化列表来进行这种操作，因为push_back知道传进来的参数的类型。但是emplace_back接受的是一个参数包，参数包不能进行匹配，所以无法使用。
mylist.push_back({ 1, 'A' });
既然在用法上没什么区别，我们再通过前面自己实现的简单string来对比一下push_back与emplace_back的效率有什么差别
int main()
{
std::list< std::pair<int, bit::string> > mylist;
mylist.emplace_back(10, "sort");
mylist.emplace_back(make_pair(20, "sort"));
cout << endl << endl;
mylist.push_back(make_pair(30, "sort"));
mylist.push_back({ 40, "sort" });
return 0;
}
运行结果：
我们发现其实两者的效率其实也相差不大，emplace_back是直接构造了，而push_back是先构造，然后再移动构造，因为移动构造的代价很低，所以效率上相差是没什么区别。
九、lambda表达式
9.1 C++98中的一个例子
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。
我们如果想对一个自定义类型按照特定的规则进行排序，那么我们就需要写一个仿函数。
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(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表达式。
10.2 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; });
}
上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函数。
9.3 lambda表达式语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type {statement}
1. lambda表达式各部分说明
- [capture-list] :捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
- (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
- mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
- ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
- {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
下面我们来实现一个两个数相加的lambda:
int main()
{
//实现一个两个数相加的lambda
auto add1 = [](int a, int b)->int {return a + b; };
cout << add1(1, 2) << endl;
return 0;
}
运行结果:
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[] {};
// 省略参数列表和返回值类型，返回值类型由编译器推导为int
int a = 3, b = 4;
[=] {return a + 3; };
// 省略了返回值类型，无返回值类型
auto fun1 = [&](int c) {b = a + c; };
fun1(10);
cout << a << " " << b << endl;
// 各部分都很完善的lambda函数
auto fun2 = [=, &b](int c)->int {return b += a + c; };
cout << fun2(10) << endl;
// 复制捕捉x
int x = 10;
auto add_x = [x](int a) mutable { x *= 2; return a + x; };
cout << add_x(10) << endl;
return 0;
}
通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。
2. 捕获列表说明
捕捉列表描述了上下文中那些数据可以被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表达式之间不能相互赋值，即使看起来类型相同
void(*PF)();
int main()
{
auto f1 = []{cout << "hello world" << endl; };
auto f2 = []{cout << "hello world" << endl; };
//f1 = f2;//编译失败，提示找不到operator=()
//允许使用一个lambda表达式拷贝构造一个新的副本
auto f3(f2);
f3();
//可以将lambda表达式赋值给相同类型的函数指针
PF = f2;
PF();
return 0;
}
9.4 函数对象与lambda表达式
函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象。
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);
// lamber
auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
r2(10000, 2);
return 0;
}
从使用方式上来看，函数对象与lambda表达式完全一样。
函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。
实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
十、包装器
function包装器
function包装器也叫做适配器。C++中的function本质是一个类模板，也是一个包装器。
那么我们来看一下，我们为什么要function呢？
下面我们先来看一段代码
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函数模板实例出了三份，函数名，函数对象，lambda表达式分别实例化了一份。
那有没有办法只实例化一份呢？
包装器可以很好的解决上面的问题
下面我们就来学习一下function包装器
std::function在头文件<functional>
//类模板原型如下
template<class T>
function;
template<class Ret,class ...Args>
class function<Ret(Args...)>
//模板参数说明：
Ret: 被调用函数的返回类型
Args...: 被调用函数的形参
下面我们先来用一下包装器
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a * b;
}
};
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b + 1;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
function<int(int, int)> f1 = f;
cout << f1(1, 2) << endl;
function<int(int, int)> f2 = Functor();
cout << f2(1, 2) << endl;
function<int(int, int)> f3 = &Plus::plusi;
cout << f3(1, 2) << endl;
function<double(Plus, double, double)> f4 = &Plus::plusd;
cout << f4(Plus(), 1.1, 2.2) << endl;
return 0;
}
运行结果：
可调用对象存储到容器中
vector<>
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
// 可调用对象存储到容器中
//vector<>
//包装器 -- 可调用对象的类型问题
int main()
{
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;
}
return 0;
}
运行结果：
可以看到，通过包装器，我们可以将f1、f2、f3包装成相同的类型，并放在vector中一起访问。
知道了包装器怎么使用之后，如何解决模板的效率低下，实例化多份的问题呢？
下面我们通过包装器来让上面的函数模板只实例化一次
//通过包装器让函数模板只出现一次
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()
{
// 函数名
std::function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
std::function<double(double)> func3 = [](double d)->double { return d / 4; };
cout << useF(func3, 11.11) << endl;
return 0;
}
运行结果：
可以看到这一次count是累加的，并且count的地址是一样的，这说明函数模板只实例化了一次。
总结：
std::function可以包装各自可调用的对象，统一可调用对象的类型，指定参数和返回值类型。现在我们就能明白前面问的那个问题了：
为什么要有包装器？
因为不包装前可调用类型存在很多问题
函数指针类型太复杂，不方便使用和理解
仿函数类型是一个类名，没有指定调用参数和返回值，得去看operator()的实现才能看出来
lambda表达式在语法层，看不到类型。底层有类型，但是基本都是lambda_uuid，也很难看。
包装器的其他一些场景：
我们来看一道题：
https://leetcode.cn/problems/evaluate-reverse-polish-notation/submissions/
class Solution {
public:
int evalRPN(vector<string>& tokens) {
//1.操作数入栈
//2.操作符，取栈顶俩个元素进行运算，运算结果继续入栈
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])//这里已经确定是操作符了，因此可以用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));//把str强转为证书再push到st
}
}
return st.top();//最后的数字就是计算结果
}
};
使用包装器的解法：
class Solution {
public:
int evalRPN(vector<string>& tokens)
{
//利用包装器将不同运算符对应的运算函数作为value，遍历时遇到运算符可以直接调用对应的函数，将参数传入即可
stack<int> st;
map<string,function<int(int,int)>> cmdFuncMap
{
{"+",[](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(cmdFuncMap[str])
{
int right = st.top();
st.pop();
int left = st.top();
st.pop();
st.push(cmdFuncMap[str](left,right));
}
else
{
st.push(stoi(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函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
调用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为第二个参数，以此类推。
下面先来看一下bind的使用：
1. 绑定的参数顺序的影响
int Sub(int a, int b)
{
return a - b;
}
int main()
{
function<int(int, int)> rSub = bind(Sub, placeholders::_1, placeholders::_2);
cout << rSub(10, 5) << endl;
function<int(int, int)> rSub1 = bind(Sub, placeholders::_2, placeholders::_1);
cout << rSub(10, 5) << endl;
function<int(int, int)> rSub2 = bind(Sub, placeholders::_1, placeholders::_2);
cout << rSub(5, 10) << endl;
return 0;
}
运行结果：
我们发现在向bind传参的时候，是严格按照placeholders的顺序来传的，跟placeholders::_1和placeholders::_2的位置没有关系，但bind调用Sub函数时，就跟placeholders::_1和placeholders::_2的位置有联系了。
2. 对板顶函数传具体参数
double Plus(int a, int b, double rate)
{
return (a + b) * rate;
}
double PPlus(int a, double rate, int b)
{
return rate * (a + b);
}
int main()
{
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;
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;
return 0;
}
运行结果：
我们可以看到，在bind中我们可以对绑定的函数中的参数进行传具体参数，不管进行传具体参数的位置在哪，其它参数我们只需要还按照placeholders::_x的顺序继续递补即可。
3. 绑定成员函数
下面来看一个例子：
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<double(int, int)> Sub1 = bind(&SubType::sub, placeholders::_1, placeholders::_2);
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;
return 0;
}
运行结果：
注意：使用std::bind绑定类的非静态成员函数时，需要进行取地址。
首先，代码定义了三个函数对象。第一个对象Sub1使用std::bind来绑定SubType类中的static成员函数，用bind邦定时可以取地址也可以不取（建议取）。这个函数接受两个参数，使用placeholders::_1和placeholders::_2表示。当调用Sub1时，它将会调用SubType类中的sub函数。
对于Sub2和Sub3，实际上还比Sub1多了一个参数
都绑定了SubType类的另一个非static子函数ssub，所以必须要进行取地址，同时还需要传入一个实例化对象，或者像Sub3直接传一个对象。
最后，通过反汇编我们可以卡到实际上function对象底层也是一个仿函数，通过重载()来调用。
7647
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
