实现shared智能指针

2021-01-25

motivation

后天有个C++实习面试, 智能指针感觉挺爱问的, 刚好实现了一下, 做此纪录, 以备日后查看.

shared_ptr

shared_ptr 会维护一个count, 每次新增加一个指向对象的指针, count + 1, 每次析构掉一个指针, count - 1; 当count == 0 的时候真正释放对象. 这一切都由shared_ptr帮你完成, 而不再需要手动delete;

构思

所有指向同一个对象的指针应该共享一个count, 因此count可以设计为一个new int, 而在shared_ptr中有一个int *的指针, 指向这个int;
同理对象也是共享的, 因此shared_ptr类中应该有一个T *的指针指向实际的data;

实现

需要支持以下操作:
- SharedPointer ptr(new T()), 即直接用一个data *指针初始化
- SharedPointer ptr, 初始化一个未指向任何对象的指针;
- SharedPointer ptr1(ptr), 用另外一个sharedptr构造;
- SharedPointer ptr2; ptr2 = ptr, 即拷贝赋值;
- int useCount(), 该对象引用计数;
- addReference(), 新增计数;
- removeReference(), 删除计数, 当计数为0的时候需要delete 计数和对象;
- T& operator *()解引用;
- T* operator ->()指针操作;

代码

//
// Created by HXiang on 2021/1/25.
//
#include <iostream>
using namespace std;

class MyClass
{
public:
    ~MyClass()
    {
        cout << "~MyClass(" << _id << ")\n";
    }

    MyClass(int i) :_id(i)
    {

    }

    void Print() const
    {
        cout << "MyClass(" << _id << ")" << endl;
    }
private:
    int _id;
};


template <class T>
class SharedPointer {
public:
    SharedPointer() : count(nullptr), pointer(nullptr) {}

    // T* 构造
    explicit SharedPointer(T *data) : count(nullptr), pointer(data) {
        addReference();
    }

    // 拷贝构造
    SharedPointer(SharedPointer<T> const &ptr) : count(ptr.count), pointer(ptr.pointer) {
        addReference();
    }

    // 析构
    ~SharedPointer() {
        removeReference();
    }

    // 拷贝赋值
    SharedPointer<T>& operator = (const SharedPointer<T> &rhs) {
        if (this != &rhs) {
            removeReference();
            count = rhs.count;
            pointer = rhs.pointer;
            addReference();
        }
        return *this;
    }

    // dereference
    T& operator *() const {
        return *pointer;
    }

    T* operator ->() const{
        return pointer;
    }


    int useCount() {
        if (count) {
            return *count;
        }
        return -1;
    }

private:
    void addReference() {
        if (!count) {
            count = new int(0);
        }
        ++(*count);
    }

    void removeReference() {
        if (count) {
            if (!--(*count)) {
                delete count;
                delete pointer;
                count = nullptr;
                pointer = nullptr;
            }
        }
    }

    int *count;
    T *pointer;
};

int main() {
    auto *p = new MyClass(1);
    SharedPointer<MyClass> sp1(p);
    SharedPointer<MyClass> sp2 = sp1;
    SharedPointer<MyClass> sp;
    cout << "sp count " << sp.useCount() << endl;
    cout << "sp1 count " << sp1.useCount() << endl;

    sp = sp2;
    cout << "sp1 count " << sp1.useCount() << endl;
    sp->Print();
}

感想

基本功还是重要啊, 感觉实现很简单, 主要还是侯捷的面向对象讲的那些注意点;

reference

主要参考知乎这篇文章:

https://zhuanlan.zhihu.com/p/63488452