C++重点基础知识整理（五）--- C++11新特性（智能指针、auto、nullptr关键字）_c++ 智能指针 和 auto

1、c++中的smart pointer四个智能指针：

shared_ptr,unique_ptr,weak_ptr,auto_ptr C++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被11弃用。
为什么要使用智能指针：
智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。

1、 auto_ptr（c++98的方案，cpp11已经抛弃）

auto_ptr 是C++标准库提供的类模板，auto_ptr对象通过初始化指向由new创建的动态内存，它是这块内存的拥有者，一块内存不能同时被分给两个拥有者。当auto_ptr对象生命周期结束时，其析构函数会将auto_ptr对象拥有的动态内存自动释放。即使发生异常，通过异常的栈展开过程也能将动态内存释放。auto_ptr不支持new 数组。

2、shared_ptr

1、基本用法：shared_ptr采用引用计数的方式管理所指向的对象。当有一个新的shared_ptr指向同一个对象时（复制shared_ptr等），引用计数加1。当shared_ptr离开作用域时，引用计数减1。当引用计数为0时，释放所管理的内存。
2、通过make_shared获取shared_ptr

cout<<"test shared_ptr base usage:"<<endl;
shared_ptr<string> p1 = make_shared<string>("");
if(p1 && p1->empty())
    *p1 = "hello";

auto p2 = make_shared<string>("world");
cout<<*p1<<' '<<*p2<<endl;

cout<<"test shared_ptr use_count:"<<endl;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()<<endl;

auto p3 = p2;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()
<<"\tp3 cnt:"<<p3.use_count()<<endl;
p2 = p1;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()
<<"\tp3 cnt:"<<p3.use_count()<<endl;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2、shared_ptr可以使用一个new表达式返回的指针进行初始化。

cout<<"test shared_ptr and new:"<<endl;
shared_ptr<int> p4(new int(1024));
//shared_ptr<int> p5 = new int(1024); // wrong, no implicit constructor
cout<<*p4<<endl;
1
2
3
4

但是，不能将一个new表达式返回的指针赋值给shared_ptr。
另外，特别需要注意的是，不要混用new和shared_ptr!

3、shared_ptr可以通过reset方法重置指向另一个对象，此时原对象的引用计数减一。

cout<<"test shared_ptr reset:"<<endl;
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"
<<p2.use_count()<<"\tp3 nt:"<<p3.use_count()<<endl;
p1.reset(new string("cpp11"));
cout<<"p1 cnt:"<<p1.use_count()<<"\tp2 cnt:"<<p2.use_count()
<<"\tp3 cnt:"<<p3.use_count()<<endl;
1
2
3
4
5
6

4、可以定制一个deleter函数，用于在shared_ptr释放对象时调用。

void print_at_delete(int *p)
{
    cout<<"deleting..."<<p<<'\t'<<*p<<endl;
    delete p;
}

cout<<"test shared_ptr deleter:"<<endl;
int *p7 = new int(1024);
shared_ptr<int> p8(p7, print_at_delete);
p8 = make_shared<int>(1025);
1
2
3
4
5
6
7
8
9
10

3、unique_ptr

1、基本用法：unique_ptr对于所指向的对象，正如其名字所示，是独占的。所以，不可以对unique_ptr进行拷贝、赋值等操作，但是可以通过release函数在unique_ptr之间转移控制权。

cout<<"test unique_ptr base usage:"<<endl;
unique_ptr<int> up1(new int(1024));
cout<<"up1: "<<*up1<<endl;
unique_ptr<int> up2(up1.release());
cout<<"up2: "<<*up2<<endl;
//unique_ptr<int> up3(up1); // wrong, unique_ptr can not copy
//up2 = up1; // wrong, unique_ptr can not copy
unique_ptr<int> up4(new int(1025));
up4.reset(up2.release());
cout<<"up4: "<<*up4<<endl;
1
2
3
4
5
6
7
8
9
10

2、上述对于拷贝的限制，有两个特殊情况，即unique_ptr可以作为函数的返回值和参数使用，这时虽然也有隐含的拷贝存在，但是并非不可行的。

cout<<"test unique_ptr base usage:"<<endl;
unique_ptr<int> up1(new int(1024));
cout<<"up1: "<<*up1<<endl;
unique_ptr<int> up2(up1.release());
cout<<"up2: "<<*up2<<endl;
//unique_ptr<int> up3(up1); // wrong, unique_ptr can not copy
//up2 = up1; // wrong, unique_ptr can not copy
unique_ptr<int> up4(new int(1025));
up4.reset(up2.release());
cout<<"up4: "<<*up4<<endl;
1
2
3
4
5
6
7
8
9
10

3、unique_ptr同样可以设置deleter，和shared_ptr不同的是，它需要在模板参数中指定deleter的类型。好在我们有decltype这个利器，不然写起来好麻烦。

cout<<"test unique_ptr deleter:"<<endl;
int *p9 = new int(1024);
unique_ptr<int, decltype(print_at_delete) *> up6(p9, print_at_delete);
unique_ptr<int> up7(new int(1025));
up6.reset(up7.release());
1
2
3
4
5

4、weak_ptr

weak_ptr一般和shared_ptr配合使用。它可以指向shared_ptr所指向的对象，但是却不增加对象的引用计数。这样就有可能出现weak_ptr所指向的对象实际上已经被释放了的情况。因此，weak_ptr有一个lock函数，尝试取回一个指向对象的shared_ptr。

cout<<"test weak_ptr basic usage:"<<endl;
auto p10 = make_shared<int>(1024);
weak_ptr<int> wp1(p10);
cout<<"p10 use_count: "<<p10.use_count()<<endl;
//p10.reset(new int(1025)); // this will cause wp1.lock() return a false obj
shared_ptr<int> p11 = wp1.lock();
if(p11) cout<<"wp1: "<<*p11<<" use count: "<<p11.use_count()<<endl;
1
2
3
4
5
6
7

5、总结

1、 shared_ptr采用引用计数的方式管理所指向的对象。
2、 shared_ptr可以使用一个new表达式返回的指针进行初始化；但是，不能将一个new表达式返回的指针赋值给shared_ptr。
3、 一旦将一个new表达式返回的指针交由shared_ptr管理之后，就不要再通过普通指针访问这块内存。
4、shared_ptr可以通过reset方法重置指向另一个对象，此时原对象的引用计数减一。
5、可以定制一个deleter函数，用于在shared_ptr释放对象时调用。
6、unique_ptr对于所指向的对象，是独占的。
7、不可以对unique_ptr进行拷贝、赋值等操作，但是可以通过release函数在unique_ptr之间转移控制权。
8、unique_ptr可以作为函数的返回值和参数使用。
9、unique_ptr同样可以设置deleter，需要在模板参数中指定deleter的类型。
10、 weak_ptr一般和shared_ptr配合使用。它可以指向shared_ptr所指向的对象，但是却不增加对象的引用计数。
11、weak_ptr有一个lock函数，尝试取回一个指向对象的shared_ptr。

2、auto关键字

1、auto关键字的含义

auto这个关键字并不是一个全新的关键字，在旧标准中，它代表的是“具有自动存储期的局部变量”；但是它在这方面并没有起到很大的作用，比如：auto int i = 10 与int i = 10是等价的， 在旧标准中我们很少会用到auto关键字，因为非静态变量在默认的情况下本就是“具有自动存储期的”。
考虑到在旧标准中auto关键字用的很少。在C++11新特性中，auto关键字不在表示存储类型指示符，而是把它改成了一个类型指示符，用来提示编译器对此类型变量做类型的自动推导。黑体部分才是最重要的，就是变量类型的自动推导。

2、举个栗子

auto a  = 0;   //推断出a类型为int
auto b = 0.0;  //推断出b类型double
auto c = 'A';  //推断出c类型是char
1
2
3

上面写的都是推断基本类型，当然C++11 auto关键字并非这样简单的运用，更多的是为了自定义类型推断。相信很多人在写迭代器时会很头痛，太长了。先写个vector类型的迭代器。

std::vector<double> sc;
std::vector<double>::iterator iter = sc.begin();
1
2

可能还有人会说，可以用typedef重新定义别名，这样是可以解决太长的问题，但这样代码又多出了一行。

typedef std::vector<double>::iterator IterVecDouble;
 
std::vector<double> sc;
IterVecDouble iter = sc.begin();
1
2
3
4

接下来用C++11 auto关键字写一下以上代码，大家可以比对看看，哪个更洁简。

std::vector<double> sc;
auto iter = sc.begin();
1
2

3、使用注意

1、使用auto关键字的变量必须有初始值。这个很好理解，没有初始值，编译器就无法推断出变量类型。
2.使用auto关键字声明变量的类型，不能自动推导出顶层的CV-qualifiers和引用类型，除非显示声明。

    int i = 10;
    int &r = i;
    auto a = r;   //此处a推断出的类型是int,会去除&引用
    a = 13; // 重新赋值
    cout << "i = " << i << " a = " << a << endl;    // 输出i=10，a=13
 
    // 只有显式声明是引用&
    auto &b = r;
    b = 15; // 重新赋值
    cout << "i = " << i << " b = " << b << endl;    // 输出i=15，a=15
1
2
3
4
5
6
7
8
9
10

3.使用auto关键字进行类型推导时，编译器会自动忽略顶层const，除非显示声明。

    const int a = 10;
    auto b = a;   //auto自动推断类型是 int
 
    a = 12; // 报错，a为const int类型，无法修改const变量
    b = 15; // 正确，b为int类型
 
    // 显示声明
    const auto c = a;
    c = 10; // 报错，c为const int类型，无法修改const变量
1
2
3
4
5
6
7
8
9

4.对于数组类型，auto关键字会推导为指针类型，除非被声明为引用。

   int a[10];
    auto b = a;   //auto推断为 int*指针类型
    cout << typeid(b).name() << endl;   // 输出：int *
 
    auto &c = a;  //显示声明& auto推断为 int[10]类型
    cout << typeid(c).name() << endl;   // 输出：int [10]
1
2
3
4
5
6

3、nullptr关键字

nullptr关键字就是表示空指针的意思，C++11之前空指针都是NULL。已经有了NULL哪为什么还要有nullptr关键字？ nullptr表示空指针，不能转换为整型类型。为了向后兼容，C++11仍允许用0（NULL)来表示空指针。建议使用nullptr而不是0(NULL)，因为更高的类型安全。

文章参考：文章一、文章二