Smart Pointers - Be Happy Every Day

概述#

Smart pointer（智能指针） 是标准库中用于管理动态资源的对象。它内部仍然保存 raw pointer，但通过构造、析构、拷贝、移动、运算符重载等机制，把资源释放逻辑封装进对象生命周期中。

本节主要围绕三类智能指针展开：

std::unique_ptr：独占式所有权，不能拷贝，只能移动；
std::shared_ptr：共享式所有权，通过 reference count 判断何时释放资源；
std::weak_ptr：弱引用，不拥有资源，用来打破 shared_ptr 循环引用。

智能指针背后综合：

templates：让智能指针可以管理任意类型 T；
operator overloading：重载 *、->、[]，让智能指针像普通指针一样使用；
copy / move semantics：决定所有权能否复制、能否转移；
reference counting：记录共享资源的所有者数量；
RAII：把资源生命周期绑定到对象生命周期。

写 C++ 程序时，应尽量让资源由对象管理。能用智能指针表达所有权时，就不要手动散落 new / delete。

目录#

概述
目录
为什么需要智能指针
- raw pointer 的问题
- RAII 的基本思想
unique_ptr：独占所有权
实现一个简化版 unique_ptr
- 管理单个对象的版本
- 管理数组的偏特化版本
shared_ptr：共享所有权
实现一个简化版 shared_ptr
- ControlBlock
- 完整实现
shared_ptr 的循环引用问题
- 循环引用为什么释放不了
- weak_ptr 的作用
UCPointer 设计

为什么需要智能指针#

raw pointer 的问题#

动态分配对象时，raw pointer 只保存地址，本身不负责释放资源：

1
#include <iostream>
2
using namespace std;
3

4
struct Resource {
5
    int data;
6

7
    Resource(int d = 0) : data(d) {}
8

9
    ~Resource() {
10
        cout << "Resource destroyed! data = " << data << endl;
11
    }
12
};
13

14
int main() {
15
    Resource* p = new Resource(7);
16

17
    // 如果忘记 delete，析构函数不会被调用，资源泄露。
18
    delete p;
19
}

如果程序中存在复杂分支、提前 return、异常抛出、跨函数传递指针等情况，手动维护 delete 很容易出错：

忘记 delete：memory leak；
重复 delete：undefined behavior；
new[] 和 delete 混用：undefined behavior；
所有权不清楚：不知道到底该由谁释放资源。

RAII 的基本思想#

RAII（Resource Acquisition Is Initialization）的核心是：

在构造函数中获得资源，在析构函数中释放资源。

智能指针就是典型的 RAII wrapper。动态资源交给智能指针对象管理后，当智能指针离开作用域时，它的析构函数会自动释放资源。

1
#include <iostream>
2
#include <memory>
3
using namespace std;
4

5
struct Resource {
6
    int data;
7

8
    Resource(int d = 0) : data(d) {}
9

10
    ~Resource() {
11
        cout << "Resource destroyed! data = " << data << endl;
12
    }
13
};
14

15
int main() {
16
    {
17
        unique_ptr<Resource> p(new Resource(7));
18
        cout << p->data << endl;
19
    } // p 离开作用域，自动 delete Resource
20

21
    cout << "before quit..." << endl;
22
}

TIP
unique_ptr 的析构函数负责 delete 它所管理的对象。只要智能指针对象本身能正常析构，资源释放就会自动发生，包括提前返回和异常栈展开的情况。

`unique_ptr`：独占所有权#

基本使用#

unique_ptr<T> 表示对一个 T 对象的 unique ownership（独占所有权）。

1
#include <iostream>
2
#include <memory>
3
using namespace std;
4

5
struct Resource {
6
    int data;
7

8
    Resource(int d = 0) : data(d) {}
9

10
    ~Resource() {
11
        cout << "Resource destroyed! data = " << data << endl;
12
    }
13
};
14

15
int main() {
16
    unique_ptr<Resource> p(new Resource(7));
17
    cout << p->data << endl;
18
}

注意初始化形式：

1
unique_ptr<Resource> p(new Resource(7));  // OK

下面这种写法不能通过：

1
unique_ptr<Resource> p = new Resource(7); // Error

原因是 unique_ptr 从 raw pointer 构造的构造函数是 explicit 的。= 初始化形式带有隐式转换 / 拷贝初始化语义，标准库不允许这样把 raw pointer 隐式转成 unique_ptr。

像指针一样使用#

智能指针不仅要管理资源，还应该使用起来像普通指针。因此 unique_ptr 重载了指针相关运算符：

1
unique_ptr<Resource> p(new Resource(7));
2

3
p->data = 10;        // operator->
4
cout << (*p).data;   // operator*
5
cout << p.get();     // 返回内部 raw pointer，只观察，不转移所有权

get() 返回的是智能指针内部保存的 raw pointer。它通常只用于观察地址或与旧接口交互，不能拿到后手动 delete。

不能拷贝#

unique_ptr 的核心语义是独占，所以不能拷贝：

1
unique_ptr<Resource> p1(new Resource(0));
2
unique_ptr<Resource> p2(new Resource(7));
3

4
p1 = p2; // Error: copy assignment is deleted

如果允许拷贝，就会出现两个 unique_ptr 同时管理同一块资源：

1
p1 ---> Resource
2
p2 ---^

这会破坏 unique ownership，并可能导致重复释放。因此 unique_ptr 删除了 copy constructor 和 copy assignment。

移动语义#

虽然不能拷贝，但可以移动。移动表示 转移所有权。

1
#include <iostream>
2
#include <memory>
3
using namespace std;
4

5
struct Resource {
6
    int data;
7

8
    Resource(int d = 0) : data(d) {}
9

10
    ~Resource() {
11
        cout << "Resource destroyed! data = " << data << endl;
12
    }
13
};
14

15
int main() {
16
    unique_ptr<Resource> p1(new Resource(0));
17
    unique_ptr<Resource> p2(new Resource(7));
18

19
    cout << "----- before move -----" << endl;
20
    cout << "p1 = " << p1.get() << endl;
21
    cout << "p2 = " << p2.get() << endl;
22
    cout << "p1 data: " << p1->data << endl;
23
    cout << "p2 data: " << p2->data << endl;
24

25
    p1 = std::move(p2);
26

27
    cout << "----- after move -----" << endl;
28
    cout << "p1 = " << p1.get() << endl;
29
    cout << "p2 = " << p2.get() << endl;
30
    cout << "p1 data: " << p1->data << endl;
31

32
    // cout << p2->data << endl; // Error at run time: p2 已经为空，不能解引用
33
}

移动后发生三件事：

p1 原来管理的 Resource(0) 被释放；
p2 原来管理的 Resource(7) 的所有权转移给 p1；
p2 变成空智能指针，p2.get() == nullptr。

所以移动后访问 p2->data 会产生空指针解引用错误。

`std::move` 的含义#

std::move(p2) 本身不搬运资源，也不释放资源。它做的是类型转换：

1
左值 p2  ->  右值引用

真正执行所有权转移的是 unique_ptr 的 move assignment operator。也就是说：

1
p1 = std::move(p2);

含义是：把 p2 转换成可以被移动的对象，然后调用 p1 的移动赋值函数。

管理动态数组#

unique_ptr 也可以管理动态数组，但类型要写成 T[]：

1
#include <iostream>
2
#include <memory>
3
using namespace std;
4

5
struct Resource {
6
    int data;
7

8
    Resource(int d = 0) : data(d) {}
9

10
    ~Resource() {
11
        cout << "Resource destroyed! data = " << data << endl;
12
    }
13
};
14

15
int main() {
16
    unique_ptr<Resource[]> arr(new Resource[10]);
17

18
    cout << "Resource data = [ ";
19
    for (int i = 0; i < 10; ++i) {
20
        cout << arr[i].data << " ";
21
    }
22
    cout << "]" << endl;
23
}

unique_ptr<Resource[]> 的析构函数会使用 delete[]，所以 10 个对象的析构函数都会被调用。

WARNING
new T 要配 delete，new T[n] 要配 delete[]。智能指针的类型也必须区分 unique_ptr<T> 和 unique_ptr<T[]>。

实现一个简化版 `unique_ptr`#

管理单个对象的版本#

一个最小版本需要做几件事：

保存内部 raw pointer；
析构时 delete；
重载 * 和 ->；
提供 get() 观察 raw pointer；
提供 release() 释放所有权但不删除资源；
提供 reset() 重新管理资源；
禁止拷贝；
支持移动。

1
#include <iostream>
2
#include <utility>
3
using namespace std;
4

5
template <typename T>
6
class u_ptr {
7
public:
8
    explicit u_ptr(T* ptr = nullptr) : p_(ptr) {}
9

10
    ~u_ptr() {
11
        delete p_;
12
    }
13

14
    T& operator*() const {
15
        return *p_;
16
    }
17

18
    T* operator->() const {
19
        return p_;
20
    }
21

22
    T* get() const {
23
        return p_;
24
    }
25

26
    T* release() {
27
        T* ptr = p_;
28
        p_ = nullptr;
29
        return ptr;
30
    }
31

32
    void reset(T* ptr = nullptr) {
33
        delete p_;
34
        p_ = ptr;
35
    }
36

37
    u_ptr(const u_ptr&) = delete;
38
    u_ptr& operator=(const u_ptr&) = delete;
39

40
    u_ptr(u_ptr&& other) noexcept
41
        : p_(other.release()) {}
42

43
    u_ptr& operator=(u_ptr&& other) noexcept {
44
        reset(other.release());
45
        return *this;
46
    }
47

48
private:
49
    T* p_;
50
};

release() 和 reset() 的语义不同：

函数	作用	是否释放原资源
`release()`	放弃当前所有权，并返回 raw pointer	不释放
`reset(ptr)`	丢弃当前资源，改为管理 `ptr`	会释放原资源

operator-> 的返回值必须是指针。编译器会继续对返回的指针执行 ->，直到最终访问到真实对象成员。

管理数组的偏特化版本#

单对象版本不能直接管理数组，因为析构和 reset() 使用的是 delete。数组版本需要对 T[] 做 partial specialization。

1
#include <cstddef>
2
#include <utility>
3

4
template <typename T>
5
class u_ptr<T[]> {
6
public:
7
    explicit u_ptr(T* ptr = nullptr) : p_(ptr) {}
8

9
    ~u_ptr() {
10
        delete[] p_;
11
    }
12

13
    T& operator[](size_t index) const {
14
        return p_[index];
15
    }
16

17
    T* get() const {
18
        return p_;
19
    }
20

21
    T* release() {
22
        T* ptr = p_;
23
        p_ = nullptr;
24
        return ptr;
25
    }
26

27
    void reset(T* ptr = nullptr) {
28
        delete[] p_;
29
        p_ = ptr;
30
    }
31

32
    u_ptr(const u_ptr&) = delete;
33
    u_ptr& operator=(const u_ptr&) = delete;
34

35
    u_ptr(u_ptr&& other) noexcept
36
        : p_(other.release()) {}
37

38
    u_ptr& operator=(u_ptr&& other) noexcept {
39
        reset(other.release());
40
        return *this;
41
    }
42

43
private:
44
    T* p_;
45
};

数组版本和单对象版本的主要差别：

析构函数使用 delete[]；
reset() 使用 delete[]；
提供 operator[]；
不提供 operator* 和 operator->，因为管理的是一组对象。

示例：

1
#include <iostream>
2
using namespace std;
3

4
struct Resource {
5
    int data;
6

7
    Resource(int d = 0) : data(d) {}
8

9
    ~Resource() {
10
        cout << "Resource destroyed! data = " << data << endl;
11
    }
12
};
13

14
int main() {
15
    u_ptr<Resource[]> arr(new Resource[10]);
16

17
    cout << "Resource data = [ ";
18
    for (int i = 0; i < 10; ++i) {
19
        cout << arr[i].data << " ";
20
    }
21
    cout << "]" << endl;
22
}

`shared_ptr`：共享所有权#

基本使用#

shared_ptr<T> 允许多个智能指针共同管理同一个对象。

1
#include <iostream>
2
#include <memory>
3
using namespace std;
4

5
struct Resource {
6
    int data;
7

8
    Resource(int d = 0) : data(d) {}
9

10
    ~Resource() {
11
        cout << "Resource destroyed! data = " << data << endl;
12
    }
13
};
14

15
int main() {
16
    shared_ptr<Resource> p2(new Resource(7));
17

18
    cout << "p2 = " << p2.get() << endl;
19
    cout << "p2 data: " << p2->data << endl;
20
    cout << "count: " << p2.use_count() << endl;
21

22
    {
23
        shared_ptr<Resource> p1(new Resource(0));
24

25
        cout << "----- before copy -----" << endl;
26
        cout << "p1 = " << p1.get() << endl;
27
        cout << "p1 data: " << p1->data << endl;
28
        cout << "p1 count: " << p1.use_count() << endl;
29

30
        p2 = p1;
31

32
        cout << "----- after copy -----" << endl;
33
        cout << "p1 = " << p1.get() << endl;
34
        cout << "p2 = " << p2.get() << endl;
35
        cout << "p1 data: " << p1->data << endl;
36
        cout << "p2 data: " << p2->data << endl;
37
        cout << "p1 count: " << p1.use_count() << endl;
38
        cout << "p2 count: " << p2.use_count() << endl;
39
    }
40

41
    cout << "before quit..." << endl;
42
    cout << "p2 count: " << p2.use_count() << endl;
43
}

reference count 的变化#

上面代码中，p2 = p1 会产生两组变化：

p2 原来管理的 Resource(7) 的引用计数减 1，变成 0，于是释放；
p2 改为和 p1 共享 Resource(0)，该对象引用计数加 1，变成 2。

作用域变化过程：

1
开始：
2
p1 ---> Resource(0), count = 1
3
p2 ---> Resource(7), count = 1
4

5
执行 p2 = p1：
6
p1 ---> Resource(0), count = 2
7
p2 ---^
8
Resource(7), count = 0，被释放
9

10
离开内层作用域：
11
p1 析构，Resource(0) count = 1
12
p2 仍然管理 Resource(0)
13

14
main 结束：
15
p2 析构，Resource(0) count = 0，被释放

shared_ptr 的资源释放规则是：

最后一个管理者消失时，资源才会释放。

移动 `shared_ptr`#

shared_ptr 也支持移动。移动时转移 control block 指针，不增加引用计数。

1
shared_ptr<Resource> p1(new Resource(0));
2
shared_ptr<Resource> p2(new Resource(7));
3

4
p2 = std::move(p1);
5

6
cout << p1.get() << endl;       // nullptr
7
cout << p1.use_count() << endl; // 0
8
cout << p2.use_count() << endl; // 1

如果自己实现的 shared_ptr 没写 move constructor 和 move assignment，那么 std::move(p1) 可能仍然会绑定到 copy constructor / copy assignment 上，最后表现成“拷贝共享”，引用计数会增加。要得到真正的移动语义，就必须显式实现移动版本。

实现一个简化版 `shared_ptr`#

ControlBlock#

shared_ptr 不能只保存 raw pointer。它还需要一份和资源绑定的引用计数。

简化实现中，可以把二者放进 ControlBlock：

1
struct ControlBlock {
2
    T* p_;
3
    size_t ref_count;
4

5
    ControlBlock(T* ptr) : p_(ptr), ref_count(1) {}
6

7
    ~ControlBlock() {
8
        delete p_;
9
    }
10
};

多个 s_ptr 对象共享同一个 ControlBlock。每多一个共享者，ref_count 加 1；每少一个共享者，ref_count 减 1；当 ref_count == 0 时，删除 ControlBlock，进而删除资源。

完整实现#

1
#include <cstddef>
2
#include <iostream>
3
#include <utility>
4
using namespace std;
5

6
template <typename T>
7
class s_ptr {
8
private:
9
    struct ControlBlock {
10
        T* p_;
11
        size_t ref_count;
12

13
        ControlBlock(T* ptr) : p_(ptr), ref_count(1) {}
14

15
        ~ControlBlock() {
16
            delete p_;
17
        }
18
    };
19

20
    ControlBlock* cb_;
21

22
    void add_shared() {
23
        if (cb_) {
24
            ++cb_->ref_count;
25
        }
26
    }
27

28
    void release_shared() {
29
        if (cb_) {
30
            --cb_->ref_count;
31
            if (cb_->ref_count == 0) {
32
                delete cb_;
33
            }
34
        }
35
    }
36

37
public:
38
    explicit s_ptr(T* ptr = nullptr)
39
        : cb_(ptr ? new ControlBlock(ptr) : nullptr) {}
40

41
    ~s_ptr() {
42
        release_shared();
43
    }
44

45
    s_ptr(const s_ptr& other)
46
        : cb_(other.cb_) {
47
        add_shared();
48
    }
49

50
    s_ptr& operator=(const s_ptr& other) {
51
        s_ptr(other).swap(*this);
52
        return *this;
53
    }
54

55
    s_ptr(s_ptr&& other) noexcept
56
        : cb_(other.cb_) {
57
        other.cb_ = nullptr;
58
    }
59

60
    s_ptr& operator=(s_ptr&& other) noexcept {
61
        s_ptr(std::move(other)).swap(*this);
62
        return *this;
63
    }
64

65
    void swap(s_ptr& other) noexcept {
66
        std::swap(cb_, other.cb_);
67
    }
68

69
    void reset(T* ptr = nullptr) {
70
        s_ptr(ptr).swap(*this);
71
    }
72

73
    T& operator*() const {
74
        return *(cb_->p_);
75
    }
76

77
    T* operator->() const {
78
        return cb_->p_;
79
    }
80

81
    T* get() const {
82
        return cb_ ? cb_->p_ : nullptr;
83
    }
84

85
    size_t use_count() const {
86
        return cb_ ? cb_->ref_count : 0;
87
    }
88

89
    explicit operator bool() const {
90
        return get() != nullptr;
91
    }
92
};

这里使用了 copy-and-swap 的写法：

1
s_ptr& operator=(const s_ptr& other) {
2
    s_ptr(other).swap(*this);
3
    return *this;
4
}

执行过程：

s_ptr(other) 复制一份临时对象，引用计数加 1；
临时对象和当前对象交换 cb_；
函数结束，临时对象析构，它现在拿着当前对象原来的 cb_，所以原资源引用计数减 1；
若原资源引用计数变成 0，则释放原资源。

这种写法的优点：

自赋值安全；
逻辑集中在 copy constructor、destructor、swap；
异常安全性更好；
assignment 代码更短。

移动构造中只拿走 cb_，不改变引用计数：

1
s_ptr(s_ptr&& other) noexcept
2
    : cb_(other.cb_) {
3
    other.cb_ = nullptr;
4
}

因为移动只是换一个管理者，不是新增管理者。

WARNING
operator* 和 operator-> 没有检查空指针。空智能指针的解引用和 raw pointer 一样是错误行为。调用前应保证 get() != nullptr 或 operator bool() 为真。

`shared_ptr` 的循环引用问题#

循环引用为什么释放不了#

shared_ptr 的问题是可能形成 circular reference（循环引用）。例如两个对象互相保存对方的 shared_ptr：

1
#include <iostream>
2
#include <memory>
3
using namespace std;
4

5
struct B;
6

7
struct A {
8
    shared_ptr<B> b;
9
    ~A() { cout << "A destroyed" << endl; }
10
};
11

12
struct B {
13
    shared_ptr<A> a;
14
    ~B() { cout << "B destroyed" << endl; }
15
};
16

17
int main() {
18
    shared_ptr<A> pa(new A);
19
    shared_ptr<B> pb(new B);
20

21
    pa->b = pb;
22
    pb->a = pa;
23
}

离开 main() 时，外部的 pa 和 pb 会析构，但对象内部仍然互相持有 shared_ptr：

1
A --shared_ptr--> B
2
^                |
3
|                v
4
+---shared_ptr---+

结果是：

A 的引用计数无法降到 0，因为 B::a 还指向它；
B 的引用计数无法降到 0，因为 A::b 还指向它；
两个对象都不会析构，资源泄露。

这类似一种“互相等待”的状态。

`weak_ptr` 的作用#

weak_ptr 是为了解决这种问题引入的弱引用：

可以观察 shared_ptr 管理的对象；
不拥有对象；
不增加 shared reference count；
需要访问对象时，用 lock() 临时获得一个 shared_ptr。

把其中一条边改成 weak_ptr：

1
#include <iostream>
2
#include <memory>
3
using namespace std;
4

5
struct B;
6

7
struct A {
8
    shared_ptr<B> b;
9
    ~A() { cout << "A destroyed" << endl; }
10
};
11

12
struct B {
13
    weak_ptr<A> a;
14
    ~B() { cout << "B destroyed" << endl; }
15
};
16

17
int main() {
18
    shared_ptr<A> pa(new A);
19
    shared_ptr<B> pb(new B);
20

21
    pa->b = pb;
22
    pb->a = pa;
23

24
    if (shared_ptr<A> locked = pb->a.lock()) {
25
        cout << "A is still alive" << endl;
26
    }
27
}

此时 B::a 不增加 A 的引用计数，循环被打破。外部 shared_ptr 释放后，资源可以正常析构。

TIP
weak_ptr 表达的是“我可以看这个对象，但我不负责延长它的生命周期”。常见用法是 parent-child 结构中的反向指针、缓存、观察者列表等。

UCPointer 设计#

从更传统的 reference counting 设计讲起，用四个类展示如何让自定义 String 共享内部表示。

`UCObject`：把引用计数放进被共享对象#

UCObject 是 use-counted object，负责保存和维护引用计数。

1
#include <cassert>
2

3
class UCObject {
4
public:
5
    UCObject() : m_refCount(0) {}
6

7
    virtual ~UCObject() {
8
        assert(m_refCount == 0);
9
    }
10

11
    UCObject(const UCObject&) : m_refCount(0) {}
12

13
    void incr() {
14
        m_refCount++;
15
    }
16

17
    void decr();
18

19
    int references() {
20
        return m_refCount;
21
    }
22

23
private:
24
    int m_refCount;
25
};
26

27
inline void UCObject::decr() {
28
    m_refCount -= 1;
29
    if (m_refCount == 0) {
30
        delete this;
31
    }
32
}

delete this 只有在对象确实由 new 创建、且不会再被访问时才合法。不能对栈对象使用这种设计。

1
StringRep* p = new StringRep("abc"); // 可以由引用计数最终 delete this
2
StringRep r("abc");                  // 栈对象不能让 decr() delete this

`UCPointer`：引用计数智能指针#

UCPointer<T> 是指向 UCObject 派生类的智能指针。它不自己保存引用计数，而是调用被管理对象的 incr() / decr()。

1
template <class T>
2
class UCPointer {
3
private:
4
    T* m_pObj;
5

6
    void increment() {
7
        if (m_pObj) {
8
            m_pObj->incr();
9
        }
10
    }
11

12
    void decrement() {
13
        if (m_pObj) {
14
            m_pObj->decr();
15
        }
16
    }
17

18
public:
19
    UCPointer(T* r = 0)
20
        : m_pObj(r) {
21
        increment();
22
    }
23

24
    ~UCPointer() {
25
        decrement();
26
    }
27

28
    UCPointer(const UCPointer<T>& p) {
29
        m_pObj = p.m_pObj;
30
        increment();
31
    }
32

33
    UCPointer& operator=(const UCPointer<T>& p) {
34
        if (m_pObj != p.m_pObj) {
35
            decrement();
36
            m_pObj = p.m_pObj;
37
            increment();
38
        }
39
        return *this;
40
    }
41

42
    T* operator->() const {
43
        return m_pObj;
44
    }
45

46
    T& operator*() const {
47
        return *m_pObj;
48
    }
49
};

引用计数操作规律：

1
p = q;

等价于：

1
p->decrement(); // 原来 p 指向的对象少一个管理者
2
p = q;
3
p->increment(); // 新对象多一个管理者

也就是：指针赋值不仅是地址赋值，还必须维护引用计数。

String / StringRep：Envelope and Letter#

Envelope and Letter 思想：

String 是 envelope：对用户暴露的外壳，提供干净接口；
StringRep 是 letter：真正保存字符串数据的内部表示；
UCPointer<StringRep> 负责共享和释放 StringRep；
StringRep 继承 UCObject，获得引用计数能力。

四个类的关系：

类	作用
`UCObject`	实现引用计数
`UCPointer<T>`	智能指针模板，维护 `UCObject` 的引用计数
`StringRep`	字符串内部表示，保存 `char*`，继承 `UCObject`
`String`	对外接口，内部 has-a `UCPointer<StringRep>`

String 的接口：

1
class String {
2
public:
3
    String(const char*);
4
    ~String();
5
    String(const String&);
6
    String& operator=(const String&);
7

8
    int operator==(const String&) const;
9
    String operator+(const String&) const;
10
    int length() const;
11
    operator const char*() const;
12

13
private:
14
    UCPointer<StringRep> m_rep;
15
};

StringRep 的接口：

1
#include <cstring>
2

3
class StringRep : public UCObject {
4
public:
5
    StringRep(const char*);
6
    ~StringRep();
7
    StringRep(const StringRep&);
8

9
    int length() const {
10
        return strlen(m_pChars);
11
    }
12

13
    int equal(const StringRep&) const;
14

15
private:
16
    char* m_pChars;
17
};

StringRep 构造和析构：

1
StringRep::StringRep(const char* s) {
2
    if (s) {
3
        int len = strlen(s) + 1;
4
        m_pChars = new char[len];
5
        strcpy(m_pChars, s);
6
    } else {
7
        m_pChars = new char[1];
8
        *m_pChars = '\0';
9
    }
10
}
11

12
StringRep::~StringRep() {
13
    delete[] m_pChars;
14
}

拷贝构造和比较：

1
StringRep::StringRep(const StringRep& sr) {
2
    int len = sr.length();
3
    m_pChars = new char[len + 1];
4
    strcpy(m_pChars, sr.m_pChars);
5
}
6

7
int StringRep::equal(const StringRep& sp) const {
8
    return strcmp(m_pChars, sp.m_pChars) == 0;
9
}

String 的实现非常干净：

1
String::String(const char* s)
2
    : m_rep(new StringRep(s)) {}
3

4
String::~String() {}
5

6
String::String(const String& s)
7
    : m_rep(s.m_rep) {}
8

9
String& String::operator=(const String& s) {
10
    m_rep = s.m_rep; // let smart pointer do work
11
    return *this;
12
}

真正的字符串操作会转发给 StringRep：

1
int String::operator==(const String& s) const {
2
    return m_rep->equal(*s.m_rep);
3
}
4

5
int String::length() const {
6
    return m_rep->length();
7
}

这里体现了智能指针的两个作用：

m_rep = s.m_rep 时自动维护引用计数；
m_rep->equal(...) 和 *s.m_rep 使用起来像普通指针。

copy-on-write#

用字符串例子展示 reference count 的变化：

1
String x("abcdef");

此时：

1
x ---> [count = 1 | "abcdef"]

拷贝构造：

1
String y = x; // shallow copy

此时 x 和 y 共享同一个 StringRep：

1
x ---+
2
     v
3
   [count = 2 | "abcdef"]
4
     ^
5
y ---+

当修改 x 时：

1
x = "Hello world"; // copy on write

为了不影响 y，x 会创建新的 StringRep，原来的共享表示引用计数减 1：

1
x ---> [count = 1 | "Hello world"]
2
y ---> [count = 1 | "abcdef"]

这就是 copy-on-write 的基本思想：

读和普通拷贝时共享数据；真正要写时，才复制一份独立数据。

这种设计的优缺点#

优点：

String 类非常干净，拷贝构造和赋值基本交给 UCPointer；
StringRep 只关心字符串存储和字符串操作；
UCObject 和 UCPointer 可以复用到其他需要引用计数的类；
通过 shallow copy 减少不必要的数据复制。

缺点：

比 raw pointer 慢，需要维护引用计数；
属于 invasive design（侵入式设计）：被管理对象必须继承 UCObject；
delete this 对对象创建方式有要求，不能用于栈对象；
所有被共享的类型都要配合这一套基类设计。

标准库 std::shared_ptr 使用的是 non-intrusive design：引用计数放在 control block 中，被管理类不需要继承特殊基类，所以适用范围更广。

概述#

目录#

为什么需要智能指针#

raw pointer 的问题#

RAII 的基本思想#

unique_ptr：独占所有权#

基本使用#

像指针一样使用#

不能拷贝#

移动语义#

std::move 的含义#

管理动态数组#

实现一个简化版 unique_ptr#

管理单个对象的版本#

管理数组的偏特化版本#

shared_ptr：共享所有权#

基本使用#

reference count 的变化#

移动 shared_ptr#

实现一个简化版 shared_ptr#

ControlBlock#

完整实现#

shared_ptr 的循环引用问题#

循环引用为什么释放不了#

weak_ptr 的作用#

UCPointer 设计#

UCObject：把引用计数放进被共享对象#

UCPointer：引用计数智能指针#

String / StringRep：Envelope and Letter#

copy-on-write#

这种设计的优缺点#

评论

`unique_ptr`：独占所有权#

`std::move` 的含义#

实现一个简化版 `unique_ptr`#

`shared_ptr`：共享所有权#

移动 `shared_ptr`#

实现一个简化版 `shared_ptr`#

`shared_ptr` 的循环引用问题#

`weak_ptr` 的作用#

`UCObject`：把引用计数放进被共享对象#

`UCPointer`：引用计数智能指针#