目录
一、新类型
二、统一的初始化
三、声明
四、智能指针
五、右值引用
六、Lambda表达式
一、新类型
C++11新增了long long和unsigned long long，以支持64位（或更宽）的整型，新增了类型char16_t 和 char32_t ，以支持16位和32位的字符表示；还新增了“原始”字符串。
cout<<"C:\\Program Files (x86)\\Dell Digital Delivery Services"<<endl;
\\必须是双斜杠，否则会报错
二、统一的初始化
C++11扩大了用大括号起的列表（初始化列表）使用范围，使其可用于所有的内置类型和用户定义的类型（即类对象）。使用初始化列表时，可添加等号（=），也可不加：
int x={9};
double y={2.25};
vector<int> v{1,2,3,4};
class person{
public:
string name;
int age;
person(string n,int g):name(n),age(g);
};
person s1("xz",18);
三、声明
1、auto
实现自动类型转换，要求显示初始化，让编译器能够将变量的类型设置为初始值的类型：
auto a = 12; //自动将a转换成int类型；
auto ptr = &a; //自动将ptr转换成int *类型，将a的地址赋给ptr；
2、decltype
decltype将变量的类型声明为表达式指定的类型。
decltype(表达式)var;//让var的类型与表达式的类型相同
比如：
int a=10;
decltype(a)b;// 因为a的类型是int，所以b的类型也是int.
double x；
int y；
decltype(x*y) q;//x*y为double型，所以q也为double型
decltype(&x) ab;//&x为double*类型，所以ab也为double*类型
注意：为了确定类型，编译器必须遍历一个核对表
第一步：如果 表达式 是一个没有用括号括起来的标识符，则var的类型与该标识符的类型相同，包括const等限定符；
double &rx=x；
const double * pd；
decltype(rx) u = y；//因为rx是double &类型，所以u也为double &类型
decltype(pd) v； //因为pd为const double *类型，所以v也为const double *类型。
第二步：如果表达式是一个函数调用，则var的类型与函数的返回类型相同
第三步：如果表达式是一个左值，则var为指向其类型的引用。要进入这一步，表达式不能是未用括号括起来的标识符。
double xx=4.4;
decltype((xx)) r2 =xx；//double &;
decltype(xx) w = xx ；//double类型
第四步：如果前面的条件都不满足，则var的类型与表达式的类型相同
int j=3；
int &k=j；
int &n=j；
decltype(j+6) i;//int型
decltype(k+n) x;// int型
decltype((k+n)) //int &型
四、智能指针
如果在程序中使用new从堆（自由存储区）分配内存，等到不需要时，应使用delete将其释放。
C++引入了智能指针auto_ptr，以帮助自动完成这个过程，智能指针是行为类似于指针的类对象。
在使用时（尤其是STL），需要更精致的机制，C++摒弃了auto_ptr，并新增了三种智能指针：
unique_ptr、share_ptr和weak_ptr。
举个例子：
格式：auto_ptr<类型> 变量名（new 类型）
如：auto_ptr<int> num(new int);
#include <memory>
void demo1(){
double *pd=new double;//普通开辟了一段内存，但是后续没有释放内存，这样会很危险
*pd=28.9;
}
//使用智能指针就可以不用考虑这个问题
void demo2(){
auto_ptr<double> ap(new double);//使用智能指针，即使后续不delete，他也会自己释放内存
*ap=26.56;
}
由于智能指针模板类的定义方式，智能指针对象的很多方面都类似于常规指针。例如，如果num是一个智能指针对象，则可以对他执行解除引用操作（*num）、用它来访问结构成员（num->m_name）、将他赋给指向相同类型的常规指针。还可以将智能指针对象赋给另一个同类型的智能指针对象。
比如：
auto_ptr<string> ps(new string("abc"));
auto_ptr<string> ab;
ab=ps;//
如果ps和ab都是常规指针，则两个指针指向同一个string对象，这样ps和ab过期时会释放一块内存两次，避免这种问题，有以下几种方式：
1、重载赋值运算符，使之执行深拷贝，这样两个指针指向不同的对象，其中一个对象是另外一个对象的副本；
2、建立所有权概念，对于特定的对象，只能有一个智能指针可拥有它，这样只有拥有对象的智能指针的析构函数会释放该对象。然后，让赋值操作转让所有权，这就是用于auto_ptr和unique_ptr的策略，但unique_ptr的策略更严格；
3、创建智能更高的指针，跟踪引用特定对象的智能指针计数。这就称为引用计数。例如，赋值时，计数将加1，而指针过期时，计数将减1.只有当最后一个指针国企时才会调用delete，这就是shared_ptr采用的策略。
同样的策略也适用于赋值构造函数。
不适用于auto_ptr的实例，因为编译时不会报错，但是执行的时候会报错。
auto_ptr<string> ps(new string("abc"));
auto_ptr<string> vo;
vo=ps;
cout<<*ps<<endl;//当把ps赋给vo时，就相当于把ps的所有权转让给vo了，所以此时解引用读取ps里的值会报错
但是可以使用shared_ptr代替auto_ptr，毕竟shared是共享的意思嘛，所以这是没问题的。
shared_ptr<string> ps(new string("def"));
shared_ptr<string> pd;
pd=ps;
cout<<*ps<<endl;
使用unique_ptr代替auto_ptr。
unique_ptr<string> ps(new string("abc"));
unique_ptr<string> pd;
pd=ps;
cout<<*ps<<endl;
这样也会报错，但是跟auto_ptr的区别就是unique_ptr编译时就会报错.
这么多的智能指针，我到底改选哪一个呢？
如果程序要使用多个指向同一个对象的指针，应该选用shared_ptr；
如果程序不需要多个指向同一个对象的指针，则可以使用unique_ptr；
如果使用new[]分配内存，应该选用unique_ptr；
如果函数使用new分配内存，并返回指向该内存的指针，将其返回类型声明为unique_ptr是不错的选择。
五、右值引用
右值引用就是必须绑定到右值的引用。我们通过&&而不是&来获得右值，右值引用有一个重要的特性-只能绑定到一个将要销毁的对象。
关于左值引用/右值引用的几点说明
1、左值表示一个对象的身份，右值表示对象的值；
int i=42;
int &r=i; //r引用i，这表示左值引用
int &&rr=42;//将rr与42绑定在一起，这是右值引用
int &&aa=i*2;//将aa与表达式i*2绑定在一起。
int &&bb=x+y;//都是临时的数值，用完就释放了
上式相当于把x+y的结果赋给临时变量temp，然后将这个临时变量temp赋给bb这个变量
2、左值引用：&，绑定到左值表达式中，如变量，函数，赋值，下标，解引用，前置递增/递减运算符；
3、右值引用：&&，绑定到字面常量，要求转换到表达式，右值表达式等；
4、左值代表的资源是持久的，右值代表的资源是短暂的；
5、const左值引用：因为是const，无法修改资源，因此绑定到暂时性资源上，也就是绑定到右值引用上；
6、变量是左值，右值引用的本质是变量，所以无法将右值引用绑定到另一个右值引用上。
六、Lambda表达式
lambda表达式又叫匿名函数，简单的理解为没有名称的函数。
lambda表达式很简单那，可以套用如下的语法格式：
[外部变量访问方式说明符]（参数）mutable noexcept/throw() -> 返回值类型
{
函数体;
}
解释：
1、[外部变量方位方式说明符]
[ ] 方括号用于向编译器表明当前是一个lambda表达式，其不能被省略。在方括号内部，可以注明当前lambda函数的函数体中可以使用哪些“外部变量”。
所谓外部变量，指的是和当前lambda表达式位于同一作用域内的所有局部变量。
这个方括号也叫捕获块，主要的类型有以下几种（用的比较多）
[ ] 默认不捕获任何变量；
[=]默认以复制捕获所有变量；
[&]默认以引用捕获所有变量；
[x]仅以复制捕获x，其他变量不捕获；
2、（参数）
和普通函数的定义一样，lambda匿名函数可以接受外部传递的多个参数，和普通函数不同的是如果不需要传递参数则连同（）一起省略。
3、mutable
此关键字可以省略，如果要使用的话之前的（）就不能省略，默认情况下，对于以值传递引入的外部变量，不允许在lambda表达式内部修改他们的值（比如const常量）。如果想要修改他们，就必须使用mutable关键字。
注意：对于以值传递方式引入的外部变量，lambda表达式修改的是拷贝的那一份，并不会修改外部的值。
int x=10;
auto lam=[x](int a)->int
{
x++;
return a+x;
}
cout<<lam(10)<<endl;//21 ,因为x自增1，变为11，11+10=21
cout<<x<<endl; //10,值传递只修改拷贝的那一份，外部不改变值得大小。
4、noexcept/throw()
可以省略，如果使用，在之前的小括号将不能省略，默认情况下lambda函数的函数体可以抛出任何类型的异常，而标注noexcept则不会出现任何的异常。
5、->返回值类型
指明lambda匿名函数的返回值类型，非常智能的是，如果lambda函数体内只有一个return语句，或者该函数返回void，则编译器会自动的识别出返回值类型。
int num[4]={3,2,4,1};
sort(num,num+4,[](int a,int b){return a>b};);//这样会自动识别出返回类型是bool类型。
6、函数体
和普通函数一样，lambda匿名函数包含的内部代码都放置在函数体内，该函数体内除了可以使用指定传递进来的参数外，还可以使用指定的外部变量以及全局范围内的所有全局变量。
具体函数为：
lambda.cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
int num[4]={9,8,4,5};
sort(num,num+4,[=](int a,int b)->bool
{
return a>b;//按照从大到小排序
}
);
for(auto a:num)
cout<<a<<" ";//9 8 5 4
cout<<endl;
return 0;
}
使用Linux编译时，使用命令：g++ -std=c++11 lambda.cpp -o lambda,这样编译才不会出错。
