1 auto_ptr<string> p1 (new string ("I reigned lonely as a cloud.")); 
2 auto_ptr<string> p2; 
3 p2 = p1; //auto_ptr不会报错.

1 unique_ptr<string> p3 (new string ("auto"));   //#4
2 unique_ptr<string> p4；                       //#5
3 p4 = p3;//此时会报错！！

1 unique_ptr<string> pu1(new string ("hello world")); 
2 unique_ptr<string> pu2; 
3 pu2 = pu1;                                      // #1 不允许
4 unique_ptr<string> pu3; 
5 pu3 = unique_ptr<string>(new string ("You"));   // #2 允许

 1 int main()
 2 {
 3     string *s1 = new string("s1");
 4 
 5     shared_ptr<string> ps1(s1);
 6     shared_ptr<string> ps2;
 7     ps2 = ps1;
 8 
 9     cout << ps1.use_count()<<endl;    //2
10     cout<<ps2.use_count()<<endl;    //2
11     cout << ps1.unique()<<endl;    //0
12 
13     string *s3 = new string("s3");
14     shared_ptr<string> ps3(s3);
15 
16     cout << (ps1.get()) << endl;    //033AEB48
17     cout << ps3.get() << endl;    //033B2C50
18     swap(ps1, ps3);    //交换所拥有的对象
19     cout << (ps1.get())<<endl;    //033B2C50
20     cout << ps3.get() << endl;    //033AEB48
21 
22     cout << ps1.use_count()<<endl;    //1
23     cout << ps2.use_count() << endl;    //2
24     ps2 = ps1;
25     cout << ps1.use_count()<<endl;    //2
26     cout << ps2.use_count() << endl;    //2
27     ps1.reset();    //放弃ps1的拥有权，引用计数的减少
28     cout << ps1.use_count()<<endl;    //0
29     cout << ps2.use_count()<<endl;    //1
30 }

 1 class B;    //声明
 2 class A
 3 {
 4 public:
 5     shared_ptr<B> pb_;
 6     ~A()
 7     {
 8         cout << "A delete\n";
 9     }
10 };
11 
12 class B
13 {
14 public:
15     shared_ptr<A> pa_;
16     ~B()
17     {
18         cout << "B delete\n";
19     }
20 };
21 
22 void fun()
23 {
24     shared_ptr<B> pb(new B());
25     shared_ptr<A> pa(new A());
26     cout << pb.use_count() << endl;    //1
27     cout << pa.use_count() << endl;    //1
28     pb->pa_ = pa;
29     pa->pb_ = pb;
30     cout << pb.use_count() << endl;    //2
31     cout << pa.use_count() << endl;    //2
32 }
33 
34 int main()
35 {
36     fun();
37     return 0;
38 }

1 class Counter
2 {
3 public:
4     Counter() : s(0), w(0){};
5     int s;    //share_ptr的引用计数
6     int w;    //weak_ptr的引用计数
7 };

 1 template <class T>
 2 class WeakPtr; //为了用weak_ptr的lock()，来生成share_ptr用，需要拷贝构造用
 3 
 4 template <class T>
 5 class SharePtr
 6 {
 7 public:
 8     SharePtr(T *p = 0) : _ptr(p)
 9     {
10         cnt = new Counter();
11         if (p)
12             cnt->s = 1;
13         cout << "in construct " << cnt->s << endl;
14     }
15     ~SharePtr()
16     {
17         release();
18     }
19 
20     SharePtr(SharePtr<T> const &s)
21     {
22         cout << "in copy con" << endl;
23         _ptr = s._ptr;
24         (s.cnt)->s++;
25         cout << "copy construct" << (s.cnt)->s << endl;
26         cnt = s.cnt;
27     }
28     SharePtr(WeakPtr<T> const &w) //为了用weak_ptr的lock()，来生成share_ptr用，需要拷贝构造用
29     {
30         cout << "in w copy con " << endl;
31         _ptr = w._ptr;
32         (w.cnt)->s++;
33         cout << "copy w  construct" << (w.cnt)->s << endl;
34         cnt = w.cnt;
35     }
36     SharePtr<T> &operator=(SharePtr<T> &s)
37     {
38         if (this != &s)
39         {
40             release();
41             (s.cnt)->s++;
42             cout << "assign construct " << (s.cnt)->s << endl;
43             cnt = s.cnt;
44             _ptr = s._ptr;
45         }
46         return *this;
47     }
48     T &operator*()
49     {
50         return *_ptr;
51     }
52     T *operator->()
53     {
54         return _ptr;
55     }
56     friend class WeakPtr<T>; //方便weak_ptr与share_ptr设置引用计数和赋值
57 
58 protected:
59     void release()
60     {
61         cnt->s--;
62         cout << "release " << cnt->s << endl;
63         if (cnt->s < 1)
64         {
65             delete _ptr;
66             if (cnt->w < 1)
67             {
68                 delete cnt;
69                 cnt = NULL;
70             }
71         }
72     }
73 
74 private:
75     T *_ptr;
76     Counter *cnt;
77 };