【C++碎碎念】C++11新特性（声明、智能指针、右值引用、lambda表达式）

目录

一、新类型

二、统一的初始化

三、声明

四、智能指针

五、右值引用

六、Lambda表达式

一、新类型

C++11新增了long long和unsigned long long，以支持64位（或更宽）的整型，新增了类型char16_t 和 char32_t ，以支持16位和32位的字符表示；还新增了“原始”字符串。

cout<<\"C:\\\\Program Files (x86)\\\\Dell Digital Delivery Services\"<

\\\\必须是双斜杠，否则会报错

二、统一的初始化

C++11扩大了用大括号起的列表（初始化列表）使用范围，使其可用于所有的内置类型和用户定义的类型（即类对象）。使用初始化列表时，可添加等号（=），也可不加：

int x={9};

double y={2.25};

vector 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 num(new int);

#include 
void demo1(){
    double *pd=new double;//普通开辟了一段内存，但是后续没有释放内存，这样会很危险
    *pd=28.9;
} 
//使用智能指针就可以不用考虑这个问题
void demo2(){
    auto_ptr ap(new double);//使用智能指针，即使后续不delete，他也会自己释放内存
    *ap=26.56;
}

由于智能指针模板类的定义方式，智能指针对象的很多方面都类似于常规指针。例如，如果num是一个智能指针对象，则可以对他执行解除引用操作（*num）、用它来访问结构成员（num->m_name）、将他赋给指向相同类型的常规指针。还可以将智能指针对象赋给另一个同类型的智能指针对象。

比如：

auto_ptr ps(new string(\"abc\"));
auto_ptr 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 ps(new string(\"abc\"));
auto_ptr vo;
vo=ps;
cout<<*ps<

shared_ptr ps(new string(\"def\"));
shared_ptr pd;
pd=ps;
cout<<*ps<

unique_ptr ps(new string(\"abc\"));
unique_ptr pd;
pd=ps;
cout<<*ps<

#include 
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<