很多人谈到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析构的时候，内存才会释放。

使用方法如下：
6 ^# e& b+ c$ l# {% \4 c

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   9 s( Q) \: I" O; [& r7 Q
2. struct ClassWrapper {
   7 a! \  e' u8 N. m# S8 \9 ?/ D
3.     ClassWrapper() {
   8 E* G+ v( c/ N5 \
4.         cout << "construct" << endl;
   
5.         data = new int[10];
   
6.     }
   & G0 E  j! g* k+ |6 L
7.     ~ClassWrapper() {
   " l: Q8 X( `: Q! e/ A" w3 y( [; V
8.         cout << "deconstruct" << endl;
   ' H6 h) T$ k# `# ~
9.         if (data != nullptr) {
   ) g. c2 m) U$ X, {( ~
10.             delete[] data;
    
11.         }
    
12.     }
    
13.     void Print() {
    
14.         cout << "print" << endl;
    ) w6 f: ~- C! J4 D8 P
15.     }
    " Y: F( `( h3 x. }7 D* h- `% r
16.     int* data;
    
17. };
    
18. 
    4 P- Y1 {+ u+ L/ S/ ?' M7 N; L
19. void Func(std::shared_ptr<ClassWrapper> ptr) {
    : W! z- p; a3 R3 h( F, z3 p
20.     ptr->Print();
    * A3 R( M) h3 A, v: F
21. }
    % M- S% B8 U9 F* h3 V
22. 
    ' Z& p4 l" G0 q! d3 {) A/ k, M
23. int main() {
    
24.     auto smart_ptr = std::make_shared<ClassWrapper>();
    & `8 h( }, P0 s( g& r% X
25.     auto ptr2 = smart_ptr; // 引用计数+1
    : l8 K2 b; F5 j4 ]2 e
26.     ptr2->Print();
    
27.     Func(smart_ptr); // 引用计数+1
    
28.     smart_ptr->Print();
    
29.     ClassWrapper *p = smart_ptr.get(); // 可以通过get获取裸指针
    
30.     p->Print();
    
31.     return 0;
    
32. }</font></font></font>
复制代码

• 智能指针还可以自定义删除器，在引用计数为0的时候自动调用删除器来释放对象的内存，代码如下：
    T! R  E/ O+ m, h1 G6 r& s
• std::shared_ptr<int> ptr(new int, [](int *p){ delete p; });
  ' ~# [7 W- ^4 {" l. K

关于shared_ptr有几点需要注意：
  J# A/ P2 N, @& e8 h

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

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

1. 
   
2. class A {
   4 j$ ]0 f$ B& P# A
3.     shared_ptr<A> GetSelf() {
   $ U/ P. ]* M8 D) d
4.        return shared_from_this();
   . F" Q: D/ {; J) C' I# X, i
5.        // return shared_ptr<A>(this); 错误，会导致double free
   5 D5 b& A$ p0 w
6.     }  
   
7. };

复制代码

! A3 K0 |7 w1 c4 Z* i

• 尽量使用make_shared，少用new。
• 不要delete get()返回来的裸指针。
• 不是new出来的空间要自定义删除器。
• 要避免循环引用，循环引用导致内存永远不会被释放，造成内存泄漏。
  1. 
     . ?' U. x1 }0 j8 u) C3 f1 S0 G
  2. using namespace std;
     
  3. struct A;
     ( h. h2 }: \* I( Q1 S+ U
  4. struct B;
     
  5. 
     1 u9 [- R% s3 ?. {/ ?- y' P
  6. struct A {
     : F* X, d9 X  F4 G; X) M
  7.    std::shared_ptr<B> bptr;
     # Q9 o: I: g$ [, d) j) ]
  8.    ~A() {
     
  9.        cout << "A delete" << endl;
     
  10.   }
      
  11. };
      : v7 P3 J9 _! E0 U
  12. 
      # C9 E5 u# M8 ~
  13. struct B {
      6 t: j! F4 f  X
  14.    std::shared_ptr<A> aptr;
      3 d$ n6 y% j/ \% p! J; X4 G
  15.    ~B() {
      
  16.        cout << "B delete" << endl;
      
  17.    }
      7 k3 c5 l9 K, W+ N% F  c5 _
  18. };
      0 u0 \, g* ]5 e+ C6 j% ~
  19. 
      - e; v5 n, R6 a, }
  20. int main() {
      
  21.    auto aaptr = std::make_shared<A>();
      
  22.    auto bbptr = std::make_shared<B>();
      7 _7 K9 J) f9 j6 F* L) z8 c
  23.    aaptr->bptr = bbptr;
      
  24.    bbptr->aptr = aaptr;
      # ^7 @1 o' v4 P6 W* u
  25.    return 0;
      
  26. }

  复制代码
  
  8 ^: `4 y8 W. H7 a$ w

上面代码，产生了循环引用，导致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. 
     
  2. struct A;
     
  3. struct B;
     
  4. 
     
  5. struct A {
     ; F! K; f' l, }0 v4 E
  6.    std::shared_ptr<B> bptr;
     
  7.    ~A() {
     
  8.        cout << "A delete" << endl;
     
  9.    }
     
  10.    void Print() {
      
  11.        cout << "A" << endl;
      - z) ?+ P5 F9 [/ h8 l: S
  12.    }
      
  13. };
      / f2 s" g6 ^; b0 \$ _6 `
  14. 
      2 P! E9 f* U. o7 _( g, Q! {- R8 p
  15. struct B {
      . W3 H% m" h4 v" U+ w4 U# S
  16.    std::weak_ptr<A> aptr; // 这里改成weak_ptr
      
  17.    ~B() {
      
  18.        cout << "B delete" << endl;
      9 v8 T5 T- R/ [! w" G5 a% ~  ]
  19.    }
      
  20.    void PrintA() {
      
  21.        if (!aptr.expired()) { // 监视shared_ptr的生命周期
      * F, f: R3 G& q- M, A; j' M
  22.            auto ptr = aptr.lock();
      
  23.            ptr->Print();
      7 N' @5 Z+ n) M. f) n
  24.       }
      
  25.    }
      " F" |9 x# {* w/ t6 C
  26. };
      
  27. 
      
  28. int main() {
      
  29.    auto aaptr = std::make_shared<A>();
      
  30.    auto bbptr = std::make_shared<B>();
      
  31.    aaptr->bptr = bbptr;
      4 j1 @: B8 U% I* c: w( y+ q
  32.    bbptr->aptr = aaptr;
      ) l7 s0 [/ `( R
  33.    bbptr->PrintA();
      
  34.    return 0;
      & G1 g0 _2 ?# _  a# K/ Z
  35. }
      
  36. 输出：
      ! g" z- n( L( ]$ H* Z8 i
  37. A
      9 c4 _4 E% c9 j
  38. A delete
      ! ]4 G- f7 e: ~$ p/ k, q
  39. B delete

  复制代码
  
  

unique_ptr

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

1. 
   % h' F. l* m" f9 W8 i8 b
2. using namespace std;
   
3. 
   
4. struct A {
     J$ t. U0 o) k7 W6 s/ [/ Z" a
5.    ~A() {
   7 A; U: u1 G; l
6.        cout << "A delete" << endl;
   
7.    }
   
8.    void Print() {
   9 g0 R, z, }- U5 w% b/ k5 C2 K- u
9.        cout << "A" << endl;
   5 D- n8 Y! f: a
10.    }
    4 v, D2 i1 f$ W  V" y
11. };
    . _/ P" w  d* b* o0 Z
12. 
    : X0 t, ?* Y8 N: a4 ]
13. 
    & ~4 t7 B" l6 H. r- X1 ?2 x
14. int main() {
    
15.    auto ptr = std::unique_ptr<A>(new A);
    % A3 ^  Z4 `- O' z0 Y3 |
16.    auto tptr = std::make_unique<A>(); // error, c++11还不行，需要c++14
    9 Q# N. g6 v9 Y8 `% L! M
17.    std::unique_ptr<A> tem = ptr; // error, unique_ptr不允许移动
    1 y# F. r. F6 }; Q4 j: p+ b
18.    ptr->Print();
    * }- S5 c9 q1 h/ ]' ^+ I5 v% `
19.    return 0;
    
20. }

复制代码

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

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

. V# e- h: F% ~0 \1 ?3 Y. J9 M5 F9 X