【C++】智能指针shared_ptr 底层源码实现_智能指针源码

智能指针：智能指针是一个模板类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止堆内存泄漏。动态分配的资源，交给一个类对象去管理，当智能指针类对象生命周期结束时，自动调用析构函数释放资源。

shared_ptr 是一种共享所有权的智能指针，它使用引用计数的方式来管理资源。每个 shared_ptr 都有一个关联的引用计数器，当引用计数为0时，它会自动删除所管理的对象。

#include <iostream>

using namespace std;

template <typename T>
class SharedPtr {
public:
    // 构造函数
    SharedPtr(T* ptr) : data_ptr(ptr), ref_count(new int(1)) {}

    // 拷贝构造函数
    SharedPtr(const SharedPtr<T>& other) 
        : data_ptr(other.data_ptr), ref_count(other.ref_count) {
        (*ref_count)++;
    }

    // 析构函数
    ~SharedPtr() {
        (*ref_count)--;
        if (*ref_count == 0) {
            delete data_ptr;
            delete ref_count;
        }
    }

    // 重载赋值运算符
    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
        if (this != &other) {
            // 这里的-1操作是将当前this对象旧的引用对象对应的计数-1
            // 表示当前this对象不指向对应的旧的对象了
            (*ref_count)--;
            if (*ref_count == 0) {
                delete data_ptr;
                delete ref_count;
            }

            // 然后将other新智能指针对应的参数值赋值给this对象
            // 复制新的引用计数和指针
            data_ptr = other.data_ptr;
            ref_count = other.ref_count;
            (*ref_count)++;
        }
        return *this;
    }
    int use_count()
    {
        return *ref_count;
    }
private:
    T* data_ptr;     // 指向分配的内存的指针
    int* ref_count;  // 引用计数
};



int main() {
	SharedPtr<int> ptr1 = new int(5);
    cout << ptr1.use_count() << endl;

    cout << "========" << endl;
    SharedPtr<int> ptr2 = new int(6);
    ptr2 = ptr1;

    cout <<ptr1.use_count() << endl;
    cout <<ptr2.use_count() << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68