很多人谈到c++，说它特别难，可能有一部分就是因为c++的内存管理吧，不像java那样有虚拟机动态的管理内存，在程序运行过程中可能就会出现内存泄漏，然而这种问题其实都可以通过c++11引入的智能指针来解决，相反我还认为这种内存管理还是c++语言的优势，因为尽在掌握。

c++11引入了三种智能指针：

• std::shared_ptr
• std::weak_ptr
• std::unique_ptr
  
  

shared_ptr

shared_ptr使用了引用计数，每一个shared_ptr的拷贝都指向相同的内存，每次拷贝都会触发引用计数+1，每次生命周期结束析构的时候引用计数-1，在最后一个shared_ptr析构的时候，内存才会释放。

使用方法如下：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   
2. struct ClassWrapper {
     C+ |$ ]. t, [+ b# _+ ^# Q
3.     ClassWrapper() {
   
4.         cout << "construct" << endl;
   5 I' N5 Q+ c4 q$ J! `' o* L
5.         data = new int[10];
   
6.     }
   ( x# Z* C3 Z! \' c
7.     ~ClassWrapper() {
   $ a! M: u" g( j7 s  l7 ^- Q) W" y+ C
8.         cout << "deconstruct" << endl;
   
9.         if (data != nullptr) {
   
10.             delete[] data;
    
11.         }
    
12.     }
    
13.     void Print() {
    $ N6 z! M# x: N+ _
14.         cout << "print" << endl;
    
15.     }
    
16.     int* data;
    ; ^, b6 M5 w1 `0 }: N0 S+ V$ m
17. };
    5 \; n/ o0 ?8 Z  I$ g/ O
18. 
    % {  W  V! q7 @$ `; n3 C6 l
19. void Func(std::shared_ptr<ClassWrapper> ptr) {
    
20.     ptr->Print();
    " @5 P. H/ p1 N" q/ g& c0 j/ E
21. }
    7 o, j7 r) o: g( |0 `' @( G. h) u
22. 
    
23. int main() {
    / `/ h/ \# Q6 L( E4 Q, F* _
24.     auto smart_ptr = std::make_shared<ClassWrapper>();
    
25.     auto ptr2 = smart_ptr; // 引用计数+1
    / S# x, D$ q3 m& }  y& A
26.     ptr2->Print();
    
27.     Func(smart_ptr); // 引用计数+1
    
28.     smart_ptr->Print();
    2 U0 T9 k( @' h, v1 y$ I1 q9 \
29.     ClassWrapper *p = smart_ptr.get(); // 可以通过get获取裸指针
    ' F; I; N5 q" x$ H6 O
30.     p->Print();
    
31.     return 0;
    
32. }</font></font></font>
复制代码

• 智能指针还可以自定义删除器，在引用计数为0的时候自动调用删除器来释放对象的内存，代码如下：
  
• std::shared_ptr<int> ptr(new int, [](int *p){ delete p; });
  & ]8 z2 q4 M6 V4 x. g: t

关于shared_ptr有几点需要注意：
$ @0 ]5 E/ Z& V- T) F" g( ~

• 不要用一个裸指针初始化多个shared_ptr，会出现double_free导致程序崩溃

• 通过shared_from_this()返回this指针，不要把this指针作为shared_ptr返回出来，因为this指针本质就是裸指针，通过this返回可能 会导致重复析构，不能把this指针交给智能指针管理。

1. 
   
2. class A {
   
3.     shared_ptr<A> GetSelf() {
   : D( k( N, p. R" q9 \7 H9 p
4.        return shared_from_this();
   6 t6 m  O+ q; k5 d
5.        // return shared_ptr<A>(this); 错误，会导致double free
   
6.     }  
   
7. };

复制代码

: B6 p& k2 ~( i  o: ?1 T* C

• 尽量使用make_shared，少用new。
• 不要delete get()返回来的裸指针。
• 不是new出来的空间要自定义删除器。
• 要避免循环引用，循环引用导致内存永远不会被释放，造成内存泄漏。
  1. 
     
  2. using namespace std;
     , @& u: _7 `" Y! Z0 W! a
  3. struct A;
     
  4. struct B;
     
  5. 
     $ O% \# s& _. }! |& \; @
  6. struct A {
     ) p; Y# N7 n  P/ I' a, H. s$ e. b
  7.    std::shared_ptr<B> bptr;
     & _3 m$ m2 g& L/ T0 T1 }- H; b! e! G
  8.    ~A() {
     7 h# B# M$ n9 g# ]: ^3 z
  9.        cout << "A delete" << endl;
     . _6 q$ `% u# _4 q
  10.   }
      
  11. };
      1 A' X. L4 {: K
  12. 
      
  13. struct B {
      
  14.    std::shared_ptr<A> aptr;
      
  15.    ~B() {
      6 m0 F9 `2 {1 s5 _6 x( i' B
  16.        cout << "B delete" << endl;
      
  17.    }
      * g4 A0 Z7 i' }+ |" k) U/ R/ L+ v) w
  18. };
      ! R) j5 p! P. P
  19. 
      5 e5 w! j% C7 O$ T! ]
  20. int main() {
      7 Q4 e' z2 I) j# G& S
  21.    auto aaptr = std::make_shared<A>();
      9 }* I+ r9 n9 n+ m
  22.    auto bbptr = std::make_shared<B>();
      
  23.    aaptr->bptr = bbptr;
      7 r3 p# U9 z5 n/ k6 E7 y3 d% d
  24.    bbptr->aptr = aaptr;
      
  25.    return 0;
      
  26. }

  复制代码
  
  

上面代码，产生了循环引用，导致aptr和bptr的引用计数为2，离开作用域后aptr和bptr的引用计数-1，但是永远不会为0，导致指针永远不会析构，产生了内存泄漏，如何解决这种问题呢，答案是使用weak_ptr。

weak_ptr

weak_ptr是用来监视shared_ptr的生命周期，它不管理shared_ptr内部的指针，它的拷贝的析构都不会影响引用计数，纯粹是作为一个旁观者监视shared_ptr中管理的资源是否存在，可以用来返回this指针和解决循环引用问题。

• 作用1：返回this指针，上面介绍的shared_from_this()其实就是通过weak_ptr返回的this指针，这里参考我之前写的源码分析shared_ptr实现的文章，最后附上链接。
• 作用2：解决循环引用问题。
  1. 
     % K, \" E/ W, o, Y# y" e- Z
  2. struct A;
     - e& T$ |6 V8 }3 u
  3. struct B;
     1 u+ {8 O, i+ c
  4. 
     ; K1 o- n/ `9 ]/ L# @" g
  5. struct A {
     
  6.    std::shared_ptr<B> bptr;
     
  7.    ~A() {
     1 s+ f" {; s6 ]2 |! m
  8.        cout << "A delete" << endl;
     
  9.    }
     
  10.    void Print() {
      6 Y2 U; g. k9 p9 Y# u! A# E* \3 l' ^
  11.        cout << "A" << endl;
      
  12.    }
      $ i  L! O' Z) P5 t& |1 E
  13. };
      
  14. 
      
  15. struct B {
      
  16.    std::weak_ptr<A> aptr; // 这里改成weak_ptr
      ( P! Y3 Q* l5 p; n) @* {! u
  17.    ~B() {
      " c3 |- O$ i, g% p
  18.        cout << "B delete" << endl;
      , V2 P  C0 A" m9 T* ^7 E0 o
  19.    }
      
  20.    void PrintA() {
      
  21.        if (!aptr.expired()) { // 监视shared_ptr的生命周期
      # o* M) d5 X; X" Y1 p
  22.            auto ptr = aptr.lock();
      
  23.            ptr->Print();
      
  24.       }
      
  25.    }
      
  26. };
      
  27. 
      
  28. int main() {
      ! j# S# o1 e5 s- L' E0 W
  29.    auto aaptr = std::make_shared<A>();
      
  30.    auto bbptr = std::make_shared<B>();
      6 e* R( z6 r- w; P/ u
  31.    aaptr->bptr = bbptr;
      
  32.    bbptr->aptr = aaptr;
      ; W; c* D' [. P" s- f4 j7 y
  33.    bbptr->PrintA();
      ' S' K- j3 o; I' c3 S0 |
  34.    return 0;
      
  35. }
        n7 U' m% ^, S! m, R
  36. 输出：
      
  37. A
      
  38. A delete
      
  39. B delete

  复制代码
  
  : a4 b$ \* \. x# n' I( X' J) J+ }- @

unique_ptr

std::unique_ptr是一个独占型的智能指针，它不允许其它智能指针共享其内部指针，也不允许unique_ptr的拷贝和赋值。使用方法和shared_ptr类似，区别是不可以拷贝：

1. 
   
2. using namespace std;
   
3. 
   
4. struct A {
   4 g/ f6 K/ K. V
5.    ~A() {
   & u! s4 p* L1 F# v. R( ]6 C
6.        cout << "A delete" << endl;
   5 J) q" W( o  A3 ?, j5 o
7.    }
   
8.    void Print() {
   
9.        cout << "A" << endl;
   6 c, P, H4 |5 H/ E5 Q. o
10.    }
    / d; l. M( U# I2 M- t- A
11. };
    
12. 
    
13. 
    
14. int main() {
    
15.    auto ptr = std::unique_ptr<A>(new A);
    
16.    auto tptr = std::make_unique<A>(); // error, c++11还不行，需要c++14
    
17.    std::unique_ptr<A> tem = ptr; // error, unique_ptr不允许移动
    
18.    ptr->Print();
    ' o! H, J: u7 k6 T
19.    return 0;
    " c$ u5 l$ _3 e) ?- o* E. s, }* J
20. }

复制代码

0 |: b4 M; ?  A: Y: ?# `

unique_ptr也可以像shared_ptr一样自定义删除器，使用方法和shared_ptr相同。

关于c++11的智能指针的使用就介绍到这里