C++11 智能指针

Bertha 。 2022-04-04 05:54 205阅读 0赞

### C++11 智能指针 ###

*  1.普通指针的缺点
 *  2. C++98的auto\_ptr(deprecated)
 *   *  Issue1所有权转移
     *  Issue2 auto\_ptr不能指向一组对象
     *  Issue3: auto\_ptr不能和标准容器一起使用
 *  3. C++11智能指针
 *   *  3.1 shared\_ptr 共享指针
     *  3.2 weak\_ptr
 *  3. unique\_ptr

> 本文主要讲解C++11中的智能指针

主要内容：

*  原始指针使用有什么缺点（主要是资源释放、证明周期、挂起引用）
 *  C++98里面的auto\_ptr有什么缺点(所有权转移问题、不能指向数组、不能与容器组合使用)
 *  C++11提出的更加智能指针： shared\_ptr、weak\_ptr、unique\_ptr各自解决了什么问题，适用场景。

# 1.普通指针的缺点 #

我们在使用C++时，经常对pointer是又敬又怕，pointer确实能够带来极大的便利，但是pointer使用不好很容易导致程序crash。最常见问题比如：内存泄漏、挂起引用等等。

如果一块内存被多个指针引用(assignment或则传参到函数等等)，但是其中某一个指针释放了内存，但是其余的指针并不知道，这样的情况下就发生了挂起引用。  
内存泄漏比较好理解，从堆中申请了内存之后忘记了释放回去就会导致内存泄漏，对于大流量的系统， 发生内存泄漏十分严重，很容易在瞬间将系统内存打爆，系统直接宕机。

有人质疑，如果我在写代码时候足够小心，并做了相应的错误验证措施，为啥还需要智能指针呢？比如：

int * ptr = new int[5];
    //....
    
    delete [] ptr;

我申请内存并适当的释放了内存，只要我代码写的规范，理论上来说是不需要所谓智能指针的。没错，但是系统不可能永远按照我们所期待的那样执行，比如我们代码在申请了内存之后，代码中间执行别的代码段发生了无可预料的错误：访问无效地址、除以0等等、或则其余程序员做维护时候在某个时机提前return了函数，这些都可能导致 delete 操作无法执行到，就会发生内存泄漏。

所以智能指针是非常有必要的。那么什么是智能指针呢?

# 2. C++98的auto\_ptr(deprecated) #

> 智能指针：在构造中，它分配内存，当离开作用域时，它会自动释放已分配的内存。这样的话，程序员就从手动管理动态内存的繁杂任务中解放出来了。

C++98标准给出了一个版本的智能指针：auto\_ptr。

我们先来看一下auto\_ptr智能指针是怎么做的：

#include <iostream>
    #include <memory>
    
    using namespace std;
    class Test
    { 
        public: 
        Test(int a = 0 ) : m_a(a) {  }
        ~Test( )
        {  
           cout << "Call destructor" << endl; 
        }
        public: int m_a;
    };
    void main( )
    {  
        auto_ptr<Test> p( new Test(5) ); 
        cout << p->m_a << endl;
    }

上面的代码会智能的释放与指针绑定的内容。首先我们申请了一块内存来保存Test实例对象那个，并将其绑定到auto\_ptr类型的 p上。当与p相关的操作执行完，p离开了作用域的时候，它所指向的内存块会被自动的释放。

上面的代码执行结果是：

5
    Calling destructor

可以知道auto\_ptr会自动调用了Test的析构器。

再比如下面的例子：

void Fun(){ 
        int a=0, b=5, c;
        if (a==0){ 
            throw "Invalid divisor";
        }
        c = b/a;
        return;
    }
    void main( )
    { 
    	try { 
    	        auto_ptr<Test> p(new Test(5));
    	        Fun();
    	        // 出错，因为p所有权在Fun函数中转移，且在Fun执行完毕时候释放掉了。
    	        cout << p->m_a << endl;
    	    } catch (char const* e){ 
    	        cout<<"Something has gone wrong"<<endl;
    	    }
    	}
    }

上面的代码执行结果是：

Call destructor
    Something has gone wrong

尽管抛出了异常，但是指针还是正常被释放了，这是因为当异常抛出时，栈松绑（stack unwinding）,当try 块中的所有对象destroy后，p 离开了该作用域，所以它绑定的内存也就释放了。

前面描述了auto\_ptr解决的问题，但是，auto\_ptr有一些根本性的问题。

## Issue1所有权转移 ##

当我们把一个auto\_ptr赋值给另外一个auto\_ptr时候，它的所有权被转移了。比如当我向一个函数传递参数是一个auto\_ptr，传递给了`auto_ptr p1` ，当函数执行完毕时候，指针的所有权不会返回给函数，而内存也会被释放掉。

比如：

void Fun(auto_ptr<Test> p1 ){ 
     cout<<p1->m_a<<endl;
    }
    void main( ){ 
    	auto_ptr<Test> p( new Test(5) ); 
    	Fun(p);
    	cout<<p->m_a<<endl;
    }

这段代码执行会导致程序崩溃，因为在main函数最后一行执行p->m\_a的时候，p指向的内存已经被释放掉了。具体过程如下：p拥有一块内存，当Fun调用时， p把关联的内存块的所有权传给了auto\_ptr p1, p1是p的copy（注：这里从Fun函数的定义式看出，函数参数时值传递，所以把p的值拷进了函数中），这时p1就拥有了之前p拥有的内存块。目前为止，一切安好。现在Fun函数执行完了，p1离开了作用域，所以p1关联的内存块也就释放了。那么p呢？p什么都没了，这就是crash的原因了，下一行代码还试图访问p，就会访问一个已经释放掉的内存，导致程序crash。

## Issue2 auto\_ptr不能指向一组对象 ##

auto\_ptr不能指向一组对象，就是说它不能和操作符new\[\]一起使用。

比如：

void main( ){ 
    	auto_ptr<Test> p(new Test[5]);
    }

上面的代码将产生一个运行时错误。因为当auto\_ptr离开作用域时，delete被默认用来释放关联的内存空间。当auto\_ptr只指向一个对象时，这当然是没问题的，但是在上面的代码里，我们在堆里创建了一组对象，应该使用delete\[\]来释放，而不是delete.

## Issue3: auto\_ptr不能和标准容器一起使用 ##

也就是auto\_ptr不能和list、vector、map之类的容器一起使用。

# 3. C++11智能指针 #

因为auto\_ptr容易产生错误，所以它也将被废弃了。C++11提供了一组新的智能指针，每一个都各有用武之地。

*  shared\_ptr
 *  unique\_ptr
 *  weak\_ptr

这三个智能指针其实都是C++标准库提供的一些封装好的class。

## 3.1 shared\_ptr 共享指针 ##

shared\_ptr最主要的概念就是共享所有权。shared\_ptr的目标很简单：多个指针可以同时指向一个对象，当最后一个shared\_ptr离开作用域时才会释放内存。  
这个目标就可以解决auto\_ptr指针的Issue1问题。

shared\_ptr解决auto\_ptr指针的Issue1问题的方法就是采用引用计数法，当然引用计数法很容易想到的就是无法解决循环引用的问题。

创建

创建一个shared\_ptr的方法主要有两种：

shared_ptr<int> sptr1( new int );
    //或则使用make_shared创建，并给初始值100
    shared_ptr<int> sptr2 = make_shared<int>(100);

前面我们已经说了，shared\_ptr其实也是一个C++标准库的类。使用make\_shared宏可以来加速创建的过程。因为shared\_ptr主动分配内存并且保存引用计数(reference count)，make\_shared 以一种更有效率的方法来实现创建工作。

上面的sptr1创建了一个shared\_ptr，指向一块内存，该内存包含一个整数100，以及引用计数1。如果通过sptr1再创建一个shared\_ptr,引用计数就会变成2. 该计数被称为强引用(strong reference)，除此之外，shared\_ptr还有另外一种引用计数叫做弱引用(weak reference)，后面将介绍。

通过调用use\_count()可以得到引用计数， 据此你能找到shared\_ptr的数量。当debug的时候，可以通过观察shared\_ptr中strong\_ref的值得到引用计数。

比如像下面的代码段；

#include "shared_ptr1.h"
    #include <iostream>
    #include <memory>
    using namespace std;
    
    void fun(shared_ptr<int> p1){ 
        p1.get();
        cout << "fun引用次数:" <<  p1.use_count() << endl;
    }
    
    int main(){ 
        shared_ptr<int> sptr1 = make_shared<int>(100);
        cout << "fun before引用次数是：" <<  sptr1.use_count() << endl;
        fun(sptr1);
        cout << "fun after引用次数是：" <<  sptr1.use_count() << endl;
    }

输出是：

fun before引用次数是：1
    fun引用次数:2
    fun after引用次数是：1

我们可以知道，当sptr1传递给fun函数的时候，会进行一次复制，sptr1复制给函数局部变量p1，所以在fun函数里面引用是2。

析构(释放)

shared\_ptr默认调用delete释放关联的资源。如果用户采用一个不一样的析构策略时，他可以自由指定构造这个shared\_ptr的策略。下面的例子是一个由于采用默认析构策略导致的问题：

void main( ){ 
    	shared_ptr<Test> sptr1( new Test[5] );
    }

shared\_ptr指向一组对象，但是当离开作用域时，默认的析构函数调用delete释放资源。实际上，我们应该调用delete\[\]来销毁这个数组。用户可以通过调用一个函数，例如一个lamda表达式，来指定一个通用的释放步骤。

void main( ){ 
     shared_ptr<Test> sptr1( new Test[5], 
            [ ](Test* p) {  delete[ ] p; } );
    }

通过指定delete\[\]来析构，上面的代码可以完美运行。

shared\_ptr接口

就像一个普通指针一样，shared\_ptr也提供解引用操作符\*,->。除此之外，它还提供了一些更重要的接口：

*  get(): 获取shared\_ptr绑定的资源.
 *  reset(): 释放关联内存块的所有权，如果是最后一个指向该资源的shared\_ptr,就释放这块内存。
 *  unique: 判断是否是唯一指向当前内存的shared\_ptr.
 *  operator bool : 判断当前的shared\_ptr是否指向一个内存块，可以用if 表达式判断。

shared\_ptr 无法解决的问题

1.不要用裸指针创建shared\_ptr

首先我们看一个规范的代码：

void main( ){ 
    	shared_ptr<int> sptr1( new int );
    	shared_ptr<int> sptr2 = sptr1;
    	shared_ptr<int> sptr3;
    	sptr3 =sptr1
    }

下表是上面代码中引用计数变化情况：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70]

所有的shared\_ptrs拥有相同的引用计数，属于相同的组。

下面我们再看另外一个例子：

void main( ){ 
    	int* p = new int;
    	shared_ptr<int> sptr1( p);
    	shared_ptr<int> sptr2( p );
    }

上述代码会产生一个错误，因为两个来自不同组的shared\_ptr指向同一个资源。下表给你关于错误原因的图景：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 1]

避免这个问题，尽量不要从一个裸指针(naked pointer)创建shared\_ptr.

2.循环引用

循环引用的例子如下：

class B;
    
    class A { 
    public:
    	A(  ) : m_sptrB(nullptr) {  };
    	~A( ){ 
    		cout<<" A is destroyed"<<endl;
    	}
    	shared_ptr<B> m_sptrB;
    };
    class B{ 
    public:
    	B(  ) : m_sptrA(nullptr) {  };
    	~B( ){ 
    		cout<<" B is destroyed"<<endl;
    	}
    	shared_ptr<A> m_sptrA;
    };
    //***********************************************************
    void main( ){ 
    	shared_ptr<B> sptrB( new B );
    	shared_ptr<A> sptrA( new A );
    	sptrB->m_sptrA = sptrA;
    	sptrA->m_sptrB = sptrB;
    }

上面的代码产生了一个循环引用.A对B有一个shared\_ptr, B对A也有一个shared\_ptr ，与sptrA和sptrB关联的资源都没有被释放，参考下表：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 2]

当sptrA和sptrB离开作用域时，它们的引用计数都只减少到1，所以它们指向的资源并没有释放！！！！！

## 3.2 weak\_ptr ##

为了解决循环引用问题，C++提供了另外一种智能指针：weak\_ptr。

weak\_ptr 拥有共享语义（sharing semantics）和不包含语义（not owning semantics）。  
共享语义指：weak\_ptr可以共享shared\_ptr持有的资源。所以可以从一个包含资源的shared\_ptr创建weak\_ptr。  
不包含语义指：weak\_ptr不支持普通指针包含的\*，->操作，它并不包含资源所以也不允许程序员操作资源。

既然如此，我们如何使用weak\_ptr呢？答案是从weak\_ptr中创建shared\_ptr然后再使用它。通过增加强引用计数，当使用时可以确保资源不会被销毁。当引用计数增加时，可以肯定的是从weak\_ptr中创建的shared\_ptr引用计数至少为1.否则，当你使用weak\_ptr就可能发生如下问题：当shared\_ptr离开作用域时，其拥有的资源会释放，从而导致了混乱。

创建

可以以shared\_ptr作为参数构造weak\_ptr。从shared\_ptr创建一个weak\_ptr增加了共享指针的弱引用计数(weak reference)，意味着shared\_ptr与其它的指针共享着它所拥有的资源。但是当shared\_ptr离开作用域时，这个计数不作为是否释放资源的依据。换句话说，就是除非强引用计数变为0，才会释放掉指针指向的资源，在这里，弱引用计数(weak reference)不起作用。

比如如下源码：

// line1
    shared_ptr<Test> sptr( new Test );
    // line2
    weak_ptr<Test> wptr( sptr );
    // line3
    weak_ptr<Test> wptr1 = wptr;

当执行line1的时候，strong ref计数变成了1。  
当执行line2的时候，strong ref计数还是1，但是weak ref的计数变成了1。  
当执行line3的时候，strong ref计数也还是1，但是weak ref的计数变成了2。

将一个weak\_ptr赋给另一个weak\_ptr也会增加弱引用计数(weak reference count)。

所以，当shared\_ptr离开作用域时，其内的资源释放了，这时候指向该shared\_ptr的weak\_ptr发生了什么？weak\_ptr过期了（expired）。

如何判断weak\_ptr是否指向有效资源，有两种方法：

1.  调用use-count()去获取引用计数，该方法只返回强引用计数，并不返回弱引用计数。
2.  调用expired()方法。比调用use\_count()方法速度更快。

从weak\_ptr调用lock()可以得到shared\_ptr或者直接将weak\_ptr转型为shared\_ptr

如之前所述，从weak\_ptr中获取shared\_ptr增加强引用计数。

那weak\_ptr是怎么解决循环引用的呢，如下代码：

class B;
    
    class A { 
    public:
    	A(  ) : m_a(5) {  };
    	~A( ){ 
    		cout<<" A is destroyed"<<endl;
    	}
    	void PrintSpB( );
    	weak_ptr<B> m_sptrB;
     	int m_a;
    };
    class B{ 
    public:
    	B(  ) : m_b(10) {  };
    	~B( ){ 
    		cout<<" B is destroyed"<<endl;
    	}
    	weak_ptr<A> m_sptrA;
     	int m_b;
    };
    void A::PrintSpB( )
    { 
    	if( !m_sptrB.expired() ){   
    		cout<< m_sptrB.lock( )->m_b<<endl;
    	}
    }
    //***********************************************************
    void main( ){ 
    	 shared_ptr<B> sptrB( new B );
    	 shared_ptr<A> sptrA( new A );
    	 sptrB->m_sptrA = sptrA;
    	 sptrA->m_sptrB = sptrB;
    	 sptrA->PrintSpB( ); 
    }

main函数执行过程中，资源释放过程如下图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 3]

# 3. unique\_ptr #

创建

unique\_ptr 不共享它的指针。它无法复制到其他 unique\_ptr，无法通过值传递到函数，也无法用于需要副本的任何标准模板库 (STL) 算法。只能移动unique\_ptr。这意味着，内存资源所有权将转移到另一 unique\_ptr，并且原始 unique\_ptr 不再拥有此资源。我们建议你将对象限制为由一个所有者所有，因为多个所有权会使程序逻辑变得复杂。因此，当需要智能指针用于纯 C++ 对象时，可使用 unique\_ptr，而当构造 unique\_ptr 时，可使用make\_unique Helper 函数。

unique\_ptr遵循着独占语义。在任何时间点，资源只能唯一地被一个unique\_ptr占有。当unique\_ptr离开作用域，所包含的资源被释放。如果资源被其它资源重写了，之前拥有的资源将被释放。所以它保证了他所关联的资源总是能被释放。

unique_ptr<int> uptr( new int );

unique\_ptr提供了创建数组对象的特殊方法，当指针离开作用域时，调用delete\[\]代替delete。当创建unique\_ptr时，这一组对象被视作模板参数的部分。这样，程序员就不需要再提供一个指定的析构方法，如下：

unique_ptr<int[ ]> uptr( new int[5] );

当把unique\_ptr赋给另外一个对象时，资源的所有权就会被转移。

记住unique\_ptr不提供复制语义（拷贝赋值和拷贝构造都不可以），只支持移动语义(move semantics)。

接口

unique\_ptr提供的接口和传统指针差不多，但是不支持指针运算。

unique\_ptr提供一个release()的方法，释放所有权。release和reset的区别在于，release仅仅释放所有权但不释放资源，reset也释放资源。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70]: /images/20220404/9e8434f2f44f4ce8970f6e0f4b83d6e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 1]: /images/20220404/5e418fd69cdf4097a36af982f6fa4141.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 2]: /images/20220404/d3ca2c8d19574331b7ed477d92cf2c8b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA4NTMyNjE_size_16_color_FFFFFF_t_70 3]: /images/20220404/3537d892b245480fab1bcbd845fee783.png