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

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

• std::shared_ptr
• std::weak_ptr
• std::unique_ptr
  
  1 c; g' u9 W. w8 f' K  s

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 {
   
3.     ClassWrapper() {
   
4.         cout << "construct" << endl;
   
5.         data = new int[10];
   ( ]2 x1 ~5 m. t3 U1 i1 s8 P3 U
6.     }
   
7.     ~ClassWrapper() {
   # n5 l* X- j: G- f3 T  i
8.         cout << "deconstruct" << endl;
   , f0 Z0 q) }. k' G9 p( }7 Z" j
9.         if (data != nullptr) {
   
10.             delete[] data;
    7 l8 \4 f8 ]3 y+ @: \
11.         }
    0 I) g$ G' X8 g4 w/ C8 x
12.     }
    
13.     void Print() {
    ) p6 g8 }) y' Q9 Q! v! M; o# J
14.         cout << "print" << endl;
    
15.     }
    # ^: X: v7 L* K( A$ @0 T
16.     int* data;
    . T2 S( r* Z/ O5 Y- N, A7 w
17. };
    0 a: x; M, m/ x; s
18. 
      F# h7 a; J* W1 M, M( {; a/ H! O
19. void Func(std::shared_ptr<ClassWrapper> ptr) {
    
20.     ptr->Print();
    ) e  y# R! {0 Y  o: M
21. }
    
22. 
    $ R2 I* q4 J2 D! u* m
23. int main() {
    
24.     auto smart_ptr = std::make_shared<ClassWrapper>();
    " t* D1 D4 |3 f& X# e! K% G7 _
25.     auto ptr2 = smart_ptr; // 引用计数+1
    
26.     ptr2->Print();
    + F1 Z2 o% y$ s) [; A9 a) n9 L9 j
27.     Func(smart_ptr); // 引用计数+1
    , ^' V) Q# _9 o, M5 x+ t
28.     smart_ptr->Print();
    
29.     ClassWrapper *p = smart_ptr.get(); // 可以通过get获取裸指针
    
30.     p->Print();
    / s; ~$ p% y4 _: b
31.     return 0;
    & F4 |& W9 G! l& ]) b7 l5 V
32. }</font></font></font>
复制代码

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

关于shared_ptr有几点需要注意：
. E1 A5 R8 w+ R" A

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

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

1. 
   
2. class A {
   0 ]  p2 e) \  i9 g9 C4 l0 U
3.     shared_ptr<A> GetSelf() {
   
4.        return shared_from_this();
   
5.        // return shared_ptr<A>(this); 错误，会导致double free
   
6.     }  
   1 F* y* r3 Z7 K3 ~# z  C
7. };

复制代码

# z" _) G% W  ]( ]% ~8 U+ U6 x" m; D; J! O

• 尽量使用make_shared，少用new。
• 不要delete get()返回来的裸指针。
• 不是new出来的空间要自定义删除器。
• 要避免循环引用，循环引用导致内存永远不会被释放，造成内存泄漏。
  1. 
     4 ]' U3 A: ^9 f/ K5 W8 ]' Z1 U
  2. using namespace std;
     5 z1 y, M. Q9 F  t. R
  3. struct A;
     
  4. struct B;
     
  5. 
     1 Q  G& V! u2 U& U, I9 b
  6. struct A {
     : Q% F. c* x) |6 \; I" y  f
  7.    std::shared_ptr<B> bptr;
     
  8.    ~A() {
     
  9.        cout << "A delete" << endl;
     / H* h( Z) O* P
  10.   }
      
  11. };
      ! M$ e1 h  k1 Y4 k1 k- a9 M( Q# h
  12. 
      
  13. struct B {
      
  14.    std::shared_ptr<A> aptr;
      & M, k9 [. C# ?& z% N
  15.    ~B() {
      - m; X9 g* l7 H. d. b$ h9 D
  16.        cout << "B delete" << endl;
      & g: G/ T+ h) j2 z! [$ ]; u. |
  17.    }
      : N  _! f/ B, H: T8 G* R6 t
  18. };
      4 t1 s' Z* B$ k6 I2 V
  19. 
      
  20. int main() {
      ( [; w8 Y, _; M; {5 w% A1 [0 g
  21.    auto aaptr = std::make_shared<A>();
      
  22.    auto bbptr = std::make_shared<B>();
      * G  l# o& O/ `- x/ K
  23.    aaptr->bptr = bbptr;
      
  24.    bbptr->aptr = aaptr;
      
  25.    return 0;
      % j; {$ z1 R; }! O5 L  k4 }
  26. }

  复制代码
  
  ' y/ H' j6 s- c0 v+ J. h/ G  V8 s

上面代码，产生了循环引用，导致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. 
     ( W! b# r- O! n1 B1 H/ m" o
  2. struct A;
     
  3. struct B;
     
  4. 
     
  5. struct A {
     
  6.    std::shared_ptr<B> bptr;
     
  7.    ~A() {
     9 y: @& K  o5 B$ m9 A0 L  V9 @& ]# [3 C
  8.        cout << "A delete" << endl;
     7 I: B1 O2 d: v+ l4 W
  9.    }
     $ d/ m4 z. R0 f9 N
  10.    void Print() {
      # e, j+ _8 O$ A2 D/ c! M4 W4 @+ h! `
  11.        cout << "A" << endl;
      ( t( B, z: D) K/ D
  12.    }
      9 F: Z$ A1 L9 P5 q# c9 s' A/ Q
  13. };
      : i$ a& u; g9 o2 q9 j8 G
  14. 
      
  15. struct B {
      + o$ h* e& A, I( C) q
  16.    std::weak_ptr<A> aptr; // 这里改成weak_ptr
      
  17.    ~B() {
      8 ?. \% I( b. F- y! R/ [( M6 i
  18.        cout << "B delete" << endl;
      
  19.    }
      9 A5 o7 a; u+ I9 E! i0 t& H
  20.    void PrintA() {
      ) S1 t' X7 Q! {
  21.        if (!aptr.expired()) { // 监视shared_ptr的生命周期
      ' _- C' E9 a/ l) l8 J2 u
  22.            auto ptr = aptr.lock();
      ' [! p+ S( B$ U) F
  23.            ptr->Print();
      
  24.       }
      
  25.    }
      
  26. };
      
  27. 
      
  28. int main() {
      8 ~  C; ^7 V( L" Q
  29.    auto aaptr = std::make_shared<A>();
      / {! P7 f8 U0 `$ A2 o4 A8 U
  30.    auto bbptr = std::make_shared<B>();
      + x9 P! Y( ^4 x) a% I
  31.    aaptr->bptr = bbptr;
      4 `& L, J5 d5 ], ]& n/ S
  32.    bbptr->aptr = aaptr;
      
  33.    bbptr->PrintA();
      
  34.    return 0;
      
  35. }
      
  36. 输出：
      
  37. A
      
  38. A delete
      
  39. B delete

  复制代码
  
    L, u7 l# t7 ^& k( M/ i$ D. u6 `

unique_ptr

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

1. 
   5 L/ g0 e' Y) q) \7 ~6 a
2. using namespace std;
   
3. 
   
4. struct A {
   ; B& n1 B% n) o6 t& D
5.    ~A() {
   3 o& A' }, J$ c8 m/ g  c
6.        cout << "A delete" << endl;
   : s/ e% i8 P& W
7.    }
   
8.    void Print() {
   
9.        cout << "A" << endl;
   ! ^. @  U  M4 ~' @" B
10.    }
    
11. };
    
12. 
    ! D+ K3 Z3 H' f# c4 K- B
13. 
    " R7 D  t! n& ?4 X/ H3 F, B
14. int main() {
    $ u( ^- U' x! K/ K1 y
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();
    0 u) E6 K5 B! G# M/ V
19.    return 0;
    
20. }

复制代码

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

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