目录

• 理解智能指针的原理
• 智能指针的使用
• 智能指针的设计和实现
  
  ; c3 j, C; Z' x2 V% S/ ^

1、智能指针的作用

C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。

理解智能指针需要从下面三个层次：

1、从较浅的层面看，智能指针是利用了一种叫做RAII（资源获取即初始化）的技术对普通的指针进行封装，这使得智能指针实质是一个对象，行为表现的却像一个指针。

2、智能指针的作用是防止忘记调用delete释放内存和程序异常的进入catch块忘记释放内存。另外指针的释放时机也是非常有考究的，多次释放同一个指针会造成程序崩溃，这些都可以通过智能指针来解决。

3、智能指针还有一个作用是把值语义转换成引用语义。C++和Java有一处最大的区别在于语义不同，在Java里面下列代码：

Animal a = new Animal();
Animal b = a;

你当然知道，这里其实只生成了一个对象，a和b仅仅是把持对象的引用而已。但在C++中不是这样，

Animal a;
' S3 @. d' g  H' rAnimal b = a;

这里却是就是生成了两个对象。

关于值语言参考这篇文章http://www.cnblogs.com/Solstice/archive/2011/08/16/2141515.html

2、智能指针的使用

智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、weak_ptr

2.1 shared_ptr的使用

shared_ptr多个指针指向相同的对象。shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，自动删除所指向的堆内存。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要加锁。

• 初始化。智能指针是个模板类，可以指定类型，传入指针通过构造函数初始化。也可以使用make_shared函数初始化。不能将指针直接赋值给一个智能指针，一个是类，一个是指针。例如std::shared_ptr p4 = new int(1);的写法是错误的
• 拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象
• get函数获取原始指针
• 注意不要用一个原始指针初始化多个shared_ptr，否则会造成二次释放同一内存
• 注意避免循环引用，shared_ptr的一个最大的陷阱是循环引用，循环，循环引用会导致堆内存无法正确释放，导致内存泄漏。循环引用在weak_ptr中介绍。
  
  / ], |" O6 i4 O* x' }

#include <iostream>
5 _0 Y$ t& X0 y+ L) l#include <memory>
, y$ o8 b$ `8 A  M
. O) n& i- j* X+ rint main() {
  g1 ~5 n) ?- ~; i' A. e2 s* P8 K    {
        int a = 10;
0 U( U/ _6 b! y8 H; a, L" S; B        std::shared_ptr<int> ptra = std::make_shared<int>(a);
        std::shared_ptr<int> ptra2(ptra); //copy
        std::cout << ptra.use_count() << std::endl;
6 A9 q+ s9 q% K: b
6 u/ S% [) K( e  Z' F8 F. O8 |        int b = 20;
+ I8 C: }4 c; M5 M# [" E8 v) ~        int *pb = &a;
        //std::shared_ptr<int> ptrb = pb;  //error
3 j5 Q+ M9 g% U8 x4 w- ~2 V$ k% B        std::shared_ptr<int> ptrb = std::make_shared<int>(b);
9 Q3 V0 w$ p* j% w        ptra2 = ptrb; //assign
        pb = ptrb.get(); //获取原始指针
1 n: [! r# F5 j- r# \
. A* W2 |. {& [# \; @& F2 \        std::cout << ptra.use_count() << std::endl;
        std::cout << ptrb.use_count() << std::endl;
    }
}
2.2 unique_ptr的使用

unique_ptr“唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。相比与原始指针unique_ptr用于其RAII的特性，使得在出现异常的情况下，动态资源能得到释放。unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。

#include <iostream>
#include <memory>

int main() {
2 q2 v! z' V( t# t4 F    {
, E9 f; M. D6 E! v3 A        std::unique_ptr<int> uptr(new int(10));  //绑定动态对象
8 X. i# k4 r& x1 A& ]+ V        //std::unique_ptr<int> uptr2 = uptr;  //不能賦值
        //std::unique_ptr<int> uptr2(uptr);  //不能拷貝
# e2 ^/ U3 P! H& W5 v        std::unique_ptr<int> uptr2 = std::move(uptr); //轉換所有權
        uptr2.release(); //释放所有权
$ h7 k) q7 @/ S" V! r2 ~, w    }
    //超過uptr的作用域，內存釋放
}
2.3 weak_ptr的使用

weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->,它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。weak_ptr可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0,但更快，表示被观测的资源(也就是shared_ptr的管理的资源)已经不复存在。weak_ptr可以使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象， 从而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr。

#include <iostream>
#include <memory>
) l' F! z0 L9 X# @/ y; c
int main() {
. \1 I% p& I  Q    {
        std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
$ K. ~( Q8 [& }2 h" [9 G        std::cout << sh_ptr.use_count() << std::endl;
/ [) |$ e( }, d- k" x8 [" b5 r6 f6 u
+ [" d& z5 _+ s; ~) H        std::weak_ptr<int> wp(sh_ptr);
7 ]9 Y, Z# Y1 w9 v9 z8 l6 E        std::cout << wp.use_count() << std::endl;

% l7 Y4 \- O1 w        if(!wp.expired()){
9 H. a$ _- L# H) S: J            std::shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
            *sh_ptr = 100;
            std::cout << wp.use_count() << std::endl;
        }
1 L( \' B# _! k    }
$ q2 U! x7 C5 E% [    //delete memory
$ T( D, ^6 O3 y$ n9 T2 N}
2.4 循环引用

考虑一个简单的对象建模——家长与子女：a Parent has a Child, a Child knowshis/her Parent。在Java 里边很好写，不用担心内存泄漏，也不用担心空悬指针，只要正确初始化myChild 和myParent，那么Java 程序员就不用担心出现访问错误。一个handle 是否有效，只需要判断其是否non null。

public class Parent
/ X* e1 i# f3 s2 F{
　　private Child myChild;
}
public class Child
{
　　private Parent myParent;
" X- ^- ~/ g7 i" k* ~. ~+ M}

在C++里边就要为资源管理费一番脑筋。如果使用原始指针作为成员，Child和Parent由谁释放？那么如何保证指针的有效性？如何防止出现空悬指针？这些问题是C++面向对象编程麻烦的问题，现在可以借助smart pointer把对象语义（pointer）转变为值（value）语义，shared_ptr轻松解决生命周期的问题，不必担心空悬指针。但是这个模型存在循环引用的问题，注意其中一个指针应该为weak_ptr。

原始指针的做法，容易出错

#include <iostream>
#include <memory>
8 P" Y4 Y$ Y! [
class Child;
class Parent;

class Parent {
private:
; t8 K9 a7 q( g; o9 P* n    Child* myChild;
2 N6 o+ Y3 y1 @+ V1 u; L) Wpublic:
    void setChild(Child* ch) {
, D' @7 G2 T2 d3 X. d" g        this->myChild = ch;
  ~9 X  |5 t; y# l    }
# h  q. `+ t+ _7 R. H
& S6 c" o: R: @# d% d    void doSomething() {
/ B" u9 d; e1 o4 i$ ^& m        if (this->myChild) {

- j. m  S1 z& f: m8 J+ j( _        }
8 u2 e/ ^' s6 ?    }
+ w. {8 \% C( X* |
    ~Parent() {
# ]$ [" c; i$ g) }# @        delete myChild;
    }
};

7 R& g: v0 i4 G8 nclass Child {
0 m' V" p. z- r& b# w& J  cprivate:
' G, G" m- H7 e$ N' m    Parent* myParent;
4 }) u0 M4 P% n/ D1 epublic:
  V: x% q! }7 y; k" d    void setPartent(Parent* p) {
5 E# O3 {5 b$ o* P7 G+ l, P- `; x5 }& a        this->myParent = p;
    }
    void doSomething() {
2 X* x' X8 @) F! ~        if (this->myParent) {

$ b$ n* q  w5 B- A6 b" g7 |& `: a        }
    }
    ~Child() {
        delete myParent;
( E7 ]. {/ B( z+ p/ }    }
};

int main() {
9 |! E3 L3 a+ d- n. W    {
        Parent* p = new Parent;
        Child* c =  new Child;
        p->setChild(c);
        c->setPartent(p);
        delete c;  //only delete one
    }
    return 0;
}
& p! f. ?6 L' o

循环引用内存泄露的问题

#include <iostream>
; n$ n$ u! ]! O) ?. y#include <memory>
" C$ A. O& u1 W
class Child;
class Parent;
3 X( S# R6 h9 a
class Parent {
/ W& S, {2 f% j* J2 mprivate:
- ^& {5 h- V$ \6 }    std::shared_ptr<Child> ChildPtr;
+ ?( f5 C- f' r" `4 hpublic:
    void setChild(std::shared_ptr<Child> child) {
        this->ChildPtr = child;
    }
- U* Z; X2 V& P- h' \
& ~! |. ^8 O* ~( ^/ m6 k    void doSomething() {
$ H" `; a# Y$ ~# w2 `, d        if (this->ChildPtr.use_count()) {
# Y& C! `- M9 g- t0 b- E
        }
; m( g' A& w& x- N    }
+ p! t) F! d# ~  w& m4 K8 H  }
    ~Parent() {
    }
; h; N7 F& \" D+ v: {};

class Child {
private:
    std::shared_ptr<Parent> ParentPtr;
  A/ d2 f: F/ |; a& W2 c; `public:
    void setPartent(std::shared_ptr<Parent> parent) {
1 q5 R, G2 a; J0 t/ L$ U$ s; y        this->ParentPtr = parent;
    }
5 w; w: w* ^. D5 C* X    void doSomething() {
        if (this->ParentPtr.use_count()) {

        }
. M  j, {3 I1 I4 }  B    }
( t+ [5 |2 N8 |% R    ~Child() {
    }
};
/ b% u: E: W5 b6 Z
9 ^& k6 x, }0 w. @  wint main() {
2 ]/ _4 \; u' }    std::weak_ptr<Parent> wpp;
    std::weak_ptr<Child> wpc;
, c* q  H# J$ {    {
' |" O) o5 [" @, z: U- u. F; _        std::shared_ptr<Parent> p(new Parent);
        std::shared_ptr<Child> c(new Child);
        p->setChild(c);
+ S+ Q: [' ?, X. E7 z  F# {6 L3 ~; z2 G7 r        c->setPartent(p);
        wpp = p;
        wpc = c;
: V- P6 w& G2 m) w        std::cout << p.use_count() << std::endl; // 2
4 o& Z+ l! y0 I/ ?7 }9 P        std::cout << c.use_count() << std::endl; // 2
    }
    std::cout << wpp.use_count() << std::endl;  // 1
7 Y+ A6 C: z$ f; J2 K6 h2 v% R    std::cout << wpc.use_count() << std::endl;  // 1
    return 0;
0 F5 r) X" S* f* _$ P5 p}

正确的做法

#include <iostream>
#include <memory>
; N- R( m! l0 i+ I, `
, g/ @, k# f' Y! N+ Jclass Child;
2 Q1 e6 p$ \4 zclass Parent;

class Parent {
" w. _# l1 t( O, j  \2 ]+ R" yprivate:
    //std::shared_ptr<Child> ChildPtr;
    std::weak_ptr<Child> ChildPtr;
3 k" l% c9 K1 d  E$ D9 Npublic:
    void setChild(std::shared_ptr<Child> child) {
        this->ChildPtr = child;
    }
: H8 \; @2 c* j% K3 M0 ^- H' r% b- D
) W( e% P3 c7 j    void doSomething() {
        //new shared_ptr
        if (this->ChildPtr.lock()) {

        }
    }

    ~Parent() {
& m8 n0 [. B+ C& q! S    }
# o1 r, O1 M- V7 J2 y9 c( ^# F};
8 R( r. j* u! @0 k: q8 e' b0 C
class Child {
3 X1 E# q4 K8 a4 i4 }* H4 dprivate:
    std::shared_ptr<Parent> ParentPtr;
6 l4 I8 O3 l$ {6 p# i( P7 Upublic:
    void setPartent(std::shared_ptr<Parent> parent) {
3 ^2 F5 G' w/ I3 m9 [        this->ParentPtr = parent;
5 O" I; Y; u; v6 w$ l/ t    }
    void doSomething() {
        if (this->ParentPtr.use_count()) {
, N/ w2 \2 M5 o3 Z8 J' l& K
        }
    }
    ~Child() {
    }
: x6 s; H  x+ T};

# Q8 X9 z% M4 x- k# mint main() {
    std::weak_ptr<Parent> wpp;
    std::weak_ptr<Child> wpc;
1 c/ ^, E$ h7 N4 a, r+ ]3 U. J, I+ ~    {
        std::shared_ptr<Parent> p(new Parent);
        std::shared_ptr<Child> c(new Child);
6 v7 i6 B0 ^+ [! d, l        p->setChild(c);
' [) \9 X' w+ \/ }        c->setPartent(p);
        wpp = p;
        wpc = c;
* ^, r/ Q. q- B2 ~' t. v        std::cout << p.use_count() << std::endl; // 2
        std::cout << c.use_count() << std::endl; // 1
    }
% V- R/ F" V( D0 c$ F/ i) ^    std::cout << wpp.use_count() << std::endl;  // 0
3 S4 X- i% `. @5 P8 z3 |% ^    std::cout << wpc.use_count() << std::endl;  // 0
    return 0;
}
3、智能指针的设计和实现

下面是一个简单智能指针的demo。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。

1 #include <iostream>
2 #include <memory>
7 b& D( K7 F5 y8 K  _( F+ }, V 3
, k+ Z8 s! Q* {0 X" G 4 template<typename T>
5 class SmartPointer {
9 B- S; d" w% Q1 ?: m5 ~ 6 private:
+ j" a6 n7 i. N. {/ T- k 7     T* _ptr;
8     size_t* _count;
9 public:
10     SmartPointer(T* ptr = nullptr) :
6 C  F/ C" c0 T+ R. Q11             _ptr(ptr) {
12         if (_ptr) {
13             _count = new size_t(1);
14         } else {
15             _count = new size_t(0);
16         }
4 O/ M- n4 D* w9 }17     }
18
% l9 q& G9 L8 H( N0 E19     SmartPointer(const SmartPointer& ptr) {
2 ^6 v  y. L3 y20         if (this != &ptr) {
8 [9 \0 u1 a4 T  w/ N& ^/ P21             this->_ptr = ptr._ptr;
% M3 k2 ]6 i! u" y" B22             this->_count = ptr._count;
23             (*this->_count)++;
24         }
25     }
26
* E( G2 V  T% \# A' T- \27     SmartPointer& operator=(const SmartPointer& ptr) {
28         if (this->_ptr == ptr._ptr) {
29             return *this;
30         }
31
32         if (this->_ptr) {
33             (*this->_count)--;
& r' f7 ^( R* w- c* E! h34             if (this->_count == 0) {
  o& d  P6 p$ D( }) I35                 delete this->_ptr;
, |5 q! A( M1 f36                 delete this->_count;
1 r; y# P8 s% E; I$ @9 Q3 C/ ]" A, ?37             }
38         }
# h' w, m" e  p39
. o- v1 h2 J! e0 R40         this->_ptr = ptr._ptr;
. F% o% F5 f2 w$ z; O( ^6 k41         this->_count = ptr._count;
42         (*this->_count)++;
: s* {4 p- z. T9 {43         return *this;
44     }
45
46     T& operator*() {
. M1 B% J$ M' \/ {. _0 V47         assert(this->_ptr == nullptr);
48         return *(this->_ptr);
" _& J9 C: N- h3 N. C  }  `49
50     }
51
% q3 s# P  c4 u1 \7 a+ y, s52     T* operator->() {
53         assert(this->_ptr == nullptr);
54         return this->_ptr;
+ S7 N4 c' m) t: b2 s1 R55     }
5 x+ m, Y; L+ P% S5 |56
57     ~SmartPointer() {
) M5 [4 d; z& ^" g/ t58         (*this->_count)--;
1 H( Q! h" q6 o' S59         if (*this->_count == 0) {
60             delete this->_ptr;
! t" @$ e+ E# I61             delete this->_count;
62         }
: `& I% v$ A+ Q! x; U* i63     }
6 F4 f/ E2 n) A$ a2 f64
" U& U1 t/ ?/ l65     size_t use_count(){
66         return *this->_count;
67     }
0 x- y' p+ p' W  Q# i7 W68 };
; y  c0 X- _! T  J! p2 S69
70 int main() {
% }- s1 C0 N+ q% Z3 ^71     {
72         SmartPointer<int> sp(new int(10));
73         SmartPointer<int> sp2(sp);
! [! Z) e" \5 P5 d3 x8 K  T74         SmartPointer<int> sp3(new int(20));
75         sp2 = sp3;
76         std::cout << sp.use_count() << std::endl;
; |  i0 [: l+ V$ [7 p! |0 y77         std::cout << sp3.use_count() << std::endl;
/ i- l$ N3 N- |8 n) F78     }
& {1 D) q* q3 e" q7 J5 I# c79     //delete operator
$ v5 ]0 v. H" R5 }* I80 }
/ D( q8 E9 y% [# r

顶一下