1、统一列表初始化
1.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;
}C++11则扩大其特性，可以不带=进行初始化，并且对于内置类型和自定义类型初始化进行了统一。
struct Point
{
int _x;
int _y;
};
int main()
{
int x1 = 1;
int x2{ 2 };
int array1[]{ 1, 2, 3, 4, 5 };
int array2[5]{ 0 };
Point p{ 1, 2 };
// C++11中列表初始化也可以适用于new表达式中
int* pa = new int[4] { 0 };
return 0;
}隐式类型转换
struct Point
{
int _x;
int _y;
};
class A
{
public:
//explicit A(int x, int y);
A(int x, int y)
:_x(x)
, _y(y)
{}
A(int x)
:_x(x)
, _y(x)
{}
private:
int _x;
int _y;
};
// 一切皆可用列表初始化，可以省略=
int main()
{
// c
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
int array3[5]{ 0 };
Point p = { 1, 2 };
// 单参数的隐式类型转换
A aa2 = 1;
A aa4 = { 1 };
A aa5 { 1 };
// 多参数的隐式类型转换
A aa1 = { 2,2 };
A aa6 { 2,2 };
const A& aa3 = { 2,2 };
int i{ 1 };
return 0;
}1.2 std::initializer_list
initializer_list是什么类型？
int main()
{
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
return 0;
} 
使用initializer_list可以方便我们进行例如vector等容器的初始化。
//容器想用不固定的{}数据个数初始化，initializer_list支持
int main()
{
vector<int> v1;
vector<int> v2(10, 1);
// 构造
vector<int> v5({ 1,2,3,4,5 });
// X自定义 = Y类型 ->隐式类型转换 X(Y mm) X支持Y为参数类型构造就可以
vector<int> v3 = {1,2,3,4,5};
vector<int> v4{ 10,20,30};
auto il1 = { 10, 20, 30 };
initializer_list<int> il2 = { 10, 20, 30 };
cout << typeid(il1).name() << endl;
cout << sizeof(il1) << endl;
pair<string, string> kv1("sort", "排序");
pair<string, string> kv2("insert", "插入");
map<string, string> dict1 = {kv1, kv2};
// 1、pair多参数隐式类型转换
// 2、initializer_list<pair>的构造
map<string, string> dict2 = { {"sort", "排序"}, {"insert", "插入"} };
return 0;
}2、声明
2.1 auto
C++11auto用来自动推断类型
int main()
{
auto il1 = { 10, 20, 30 };
initializer_list<int> il2 = { 10, 20, 30 };
cout << typeid(il1).name() << endl;
cout << typeid(il2).name() << endl;
return 0;
}2.2 decltype
关键字decltype将变量的类型声明为表达式指定的类型。
template<class T>
class B
{
public:
T* New(int n)
{
return new T[n];
}
};
auto func1()
{
list<int> lt;
auto ret = lt.begin();
return ret;
}
int main()
{
list<int>::iterator it1;
// typeid推出时一个单纯的字符串
cout << typeid(it1).name() << endl;
// 不能用来定义对象
//typeid(it1).name() it2;
// 可以用来定义对象
decltype(it1) it2;
cout << typeid(it2).name() << endl;
auto it3 = it1;
cout << typeid(it3).name() << endl;
auto ret3 = func1();
B<decltype(ret3)> bb1;
map<string, string> dict2 = { {"sort", "排序"}, {"insert", "插入"} };
auto it4 = dict2.begin();
B<decltype(it4)> bb2;
B<std::map<std::string, std::string>::iterator> bb2;
// auto和decltype有些地方增加代码读起来难度
return 0;
}2.3 nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示
整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
3、范围for循环
底层其实就是迭代器，使用更方便。
int main()
{
vector<int> v = { 1, 2, 3, 4, 5 };
for (auto e : v)
{
cout << e << endl;
}
return 0;
}4、STL新增容器
5、右值引用和移动语义
5.1 左值引用和右值引用
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。
什么是左值？什么是右值？
int main()
{
// 左值是一个表达式，可以取地址的
// 左值和右值，能否取地址
// 左值：可以取地址的
// 右值：不可以取地址的
int a = 10;
int b = a;
const int c = 10;
int* p = &a;
vector<int> v(10, 1);
v[1];
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;
cout << &(*p) << endl;
cout << &(v[1]) << endl;
return 0;
}什么是左值引用？什么是右值引用？两者区别？
int main()
{
// 10、string("1111")、to_string(123), x+y
// cout << &10 << endl;
// cout << &string("1111") << endl;
// cout << &to_string(123) << endl;
int x = 1, y = 2;
//cout << &(x + y) < endl;//x+y结果为临时变量，不能直接取地址，右值
// 右值引用，给右值取别名
// 纯右值 （内置类型的）
// 将亡值 （自定义类型的）
int&& rref1 = (x + y);
string&& rref2 = string("1111");
string&& rref3 = to_string(123);
int&& rref4 = 10;
// 左值引用能否给右值取别名 -- 不可以，但是const左值引用可以
const string& ref1 = string("1111");
const int& ref2 = 10;
// 右值引用能否给左值取别名 -- 不可以，但是可以给move以后的左值区别
string s1("1111");
string&& rref5 = move(s1);
return 0;
}5.2 右值引用使用场景和意义
前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的！
左值引用意义：左值引用的意义是减少拷贝，提高效率。
左值引用的场景
void func1(const string& s);
string& func2();
左值引用返回值的问题没有彻底解决，如果返回值是func2中局部对象，不能用引用返回。
那么就需要有构造函数的右值引用版本，这样能够减少局部对象返回时构造的消耗。
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;
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}
// 移动构造
// 右值(将亡值)
string(string&& s)
:_str(nullptr)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
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)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
bit::string str;
while (value > 0)
{
int x = value % 10;
value /= 10;
str += ('0' + x);
}
if (flag == false)
{
str += '-';
}
std::reverse(str.begin(), str.end());
return str;
}
}
int main()
{
bit::string ret1 = bit::to_string(1234);
cout << ret1.c_str() << endl;
/*bit::string ret1;
ret1 = bit::to_string(1234);*/
return 0;
}
右值引用和移动语义解决上述问题：
在bit::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不
用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。
不仅仅有移动构造，还有移动赋值！！！
与移动构造类似！
STL中的容器都是增加了移动构造和移动赋值：
5.3 右值引用引用左值及其一些更深入的使用场景分析
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
经过move后原来的变量将为空
int main()
{
bit::string ret1;
ret1 = bit::to_string(1234);
//bit::string ret1 = bit::to_string(1234);
//cout << ret1.c_str() << endl;
/*std::string s1("11111111111111111111111");
std::string s2 = s1;
std::string s3 = move(s1);*/ //move后将成为右值，但同时将s1中的数据夺去，本质是掠夺资源
return 0;
}右值引用本质是左值！！！
int main()
{
std::string s3("22222222222");
// 左值引用
std::string& s4 = s3;
cout << &s4 << endl;
// 右值引用
std::string&& s1 = std::string("111111111");
// s1是左值（右值引用本身是左值）
cout << &s1 << endl;
//cout << &std::string("111111111") << endl;
std::string& s5 = s1;
std::string&& s6 = std::string("111111111111111111111111111111111111111");
std::string& s7 = s6;
return 0;
}STL容器插入接口函数也增加了右值引用版本：
int main()
{
bit::list<bit::string> lt;
cout << "*************************" << endl << endl;
bit::string s1("1111");
// 这里调用的是拷贝构造
lt.push_back(s1);
cout << endl;
// 这里调用的是移动构造
lt.push_back(bit::string("22222"));
//lt.push_back("22222");
// 上面效率提升，针对的是自定义类型的深拷贝的类，因为深拷贝的类才有转移资源的移动系列函数
// 对于内置类型，和浅拷贝自定义类型，没有移动系列函数
/*bit::list<int> lt1;
lt1.push_back(10);
int x = 20;
lt1.push_back(x);*/
return 0;
}记住若要增加移动语义版本的函数，就需要一层一层往上把经过右值引用的变量名属性却为左值属性，都要move后转换为右值属性，才能正确使用移动语义版本传下去。
5.4 完美转发
1.模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
2.模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
3.但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
4.我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发。
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; }
// 右值引用，引用后，右值引用本身属性变成左值
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
// 函数模版里面，这里可以叫万能引用
// 实参传左值，就推成左值引用
// 实参传右值，就推成右值引用
template<typename T>
void PerfectForward(T&& t)
{
//Fun((T&&)t);
Fun(forward<T>(t));
}
//void PerfectForward(int&& t)
//{
// Fun((int&&)t);
//}
//
//void PerfectForward(int& t)
//{
// Fun((int&)t);
//}
//
//void PerfectForward(const int&& t)
//{
// Fun((const int&&)t);
//}
//
//void PerfectForward(const int& t)
//{
// Fun((const int&)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;
}6、新的类功能
6.1 默认成员函数
原来C++有六个默认成员函数。
1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载
最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。
C++11 新增了两个：移动构造函数和移动赋值运算符重载。
- 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
- 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
- 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值
即是析构，拷贝，拷贝赋值重载，这些都是需要我们发生深拷贝时要自己写的，所以三者是一体的，任意一个出现，就不可能生成移动构造。
6.2 类成员变量初始化
类成员变量可以给缺省值，这里不做细谈，已经说明过。
6.3 强制生成默认成员函数的关键字
default：可以使一个不会默认生成的成员函数默认生成
比如我们写了拷贝构造编译器将不能默认生成移动构造，那么default就派上用场了。
Person(Person&& p) = default;
6.4 禁止生成默认成员函数的关键字
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
// 这个类只能在堆上生成对象
class HeapOnly
{
public:
static HeapOnly* CreateObj()
{
return new HeapOnly;
}
// C++11
HeapOnly(const HeapOnly&) = delete;
// C++98 私有+只声明不实现
private:
//HeapOnly(const HeapOnly&);
HeapOnly()
{}
int _a = 1;
};
int main()
{
//HeapOnly ho1;
//HeapOnly* p1 = new HeapOnly;
HeapOnly* p2 = HeapOnly::CreateObj();
// 不能被拷贝，才能禁止
//HeapOnly obj(*p2);
return 0;
}6.5 继承和多态中的final与override关键字
加上final，表示不能被继承不能被重写，override表示放在派生类的虚函数检查是否完成重写，如果没有完成重写就会报错。
7、lambda表达式
7.1 C++98中的一个例子
C++98中我们在对一个内置类型或自定义类型进行排序时，我们常常就会用到仿函数来规定排序的规则。
#include<algorithm>
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算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。
7.2 lambda表达式
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());
auto priceLess = [](const Goods& g1, const Goods& g2)
{
return g1._price < g2._price;
};
sort(v.begin(), v.end(), priceLess);
cout << typeid(priceLess).name() << endl;
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表达式实际上是一个匿名函数。
7.3 lambda表达式语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement
}
capture-list：捕捉列表parameters：参数列表，与普通函数的参数列表一致，如果不需要参数传递，则可以
连同()一起省略。mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量
性。使用该修饰符时，参数列表不可省略(即使参数为空)return-type：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回
值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推
导。statement：函数体
捕捉列表说明：
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针
#include<iostream>
using namespace std;
//局部的匿名函数
int main()
{
int a = 1, b = 2;
auto swap1 = [](int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
};
swap1(a, b);
// 捕捉a b对象给lambda
// mutable可以修改传值捕捉对象(日常一般不需要)
// 因为a b是拷贝过来，虽然修改也不改变外面的a b
auto swap2 = [a, b]() mutable
{
int tmp = a;
a = b;
b = tmp;
};
swap2();
// 引用方式捕捉
auto swap3 = [&a, &b]()
{
int tmp = a;
a = b;
b = tmp;
};
swap3();
int* pa = &a, * pb = &b;
auto swap4 = [pa, pb]()
{
int tmp = *pa;
*pa = *pb;
*pb = tmp;
};
swap4();
return 0;
}
int main()
{
int a = 1, b = 2, c = 3, d = 4, e = 5;
// 传值捕捉所有对象
auto func1 = [=]()
{
return a + b + c * d;
};
cout << func1() << endl;
// 传引用捕捉所有对象
auto func2 = [&]()
{
a++;
b++;
c++;
d++;
e++;
};
func2();
cout << a << b << c << d << e << endl;
// 混合捕捉，传引用捕捉所有对象，但是d和e传值捕捉
auto func3 = [&, d, e]()
{
a++;
b++;
c++;
//d++;
//e++;
};
func3();
cout << a << b << c << d << e << endl;
// a b传引用捕捉，d和e传值捕捉
auto func4 = [&a, &b, d, e]() mutable
{
a++;
b++;
d++;
e++;
};
func4();
cout << a << b << c << d << e << endl;
return 0;
}7.4 函数对象与lambda表达式
lambda表达式在底层其实就是仿函数！！！
