c++自己实现智能指针：auto_ptr、shared_ptr、unique_ptr

auto_ptr

template<typename T>
class my_auto_ptr
{
public:
    //构造
    my_auto_ptr(T* ptr) : m_ptr(ptr) {}
    my_auto_ptr(my_auto_ptr<T>& other) {
        m_ptr = other.m_ptr;
        other.m_ptr = nullptr;
    }
    my_auto_ptr& operator=(const my_auto_ptr& other) {
        if (this != &other)
        {
            delete m_ptr;
            m_ptr = other.m_ptr;
            other.m_ptr = nullptr;
        }
        return *this;
    }
    ~my_auto_ptr() { delete m_ptr; }

    T* get() {
        return m_ptr;
    }

    void release() { delete m_ptr; m_ptr = nullptr; }
    void reset() { release(); }
    T& operator*() const { return *m_ptr; }
    T* operator->() const { return m_ptr; }

protected:
    T* m_ptr;
};

//对void类型特化
template<> 
class my_auto_ptr<void>
{

};

shared_ptr

template<typename T>
class my_shared_ptr
{
private:
    class actual_shared_ptr
    {
    public:
        actual_shared_ptr(T* ptr) : m_ptr(ptr), m_count(1) {}
        ~actual_shared_ptr() { delete m_ptr; }

        T* m_ptr;
        unsigned int m_count;
    };
    actual_shared_ptr* m_actual_ptr;

public:
    explicit my_shared_ptr(T* ptr): m_actual_ptr(new actual_shared_ptr(ptr)) {}
    my_shared_ptr(my_shared_ptr& other) {
        m_actual_ptr = other.m_actual_ptr;
        increase();
    }
    my_shared_ptr& operator=(my_shared_ptr& other) {
        if (m_actual_ptr != other.m_actual_ptr)
        {
            m_actual_ptr = other.m_actual_ptr;
            increase();
        }
        return *this;
    }

    ~my_shared_ptr() {
        decrease();
    }

    unsigned int count() {
        return m_actual_ptr->m_count;
    }
    T& operator* () const {
        return *(m_actual_ptr->m_ptr);
    }

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

protected:
    void decrease() {
        if (--(m_actual_ptr->m_count) == 0) {
            delete m_actual_ptr;
            m_actual_ptr = nullptr;
        }            
    }
    void increase() { ++(m_actual_ptr->m_count); }
protected:
    T* m_ptr;
    unsigned int m_count;
};

template<>
class my_shared_ptr<void> {};

unique_ptr

class my_uptr_delete
{
public:
    template<typename T>
    void operator()(T* ptr) const {
        if (ptr) delete ptr;
    }
};

class my_uptr_delete_arr
{
public:
    template<typename T>
    void operator()(T* ptr) const{
        if (ptr) delete[] ptr;
    }
};

template<typename T, typename D = my_uptr_delete >
class my_unique_ptr
{
public:
    explicit my_unique_ptr(T* ptr = nullptr, const D& d = D()) : m_ptr(ptr), m_del(d){}
    ~my_unique_ptr() { m_del(m_ptr); }

    //删除拷贝和赋值
    my_unique_ptr(const my_unique_ptr& ptr) = delete;
    my_unique_ptr& operator=(const my_unique_ptr& ptr) = delete;

    //可拷贝赋值一个将被销毁的unique_ptr
    my_unique_ptr(my_unique_ptr&& rptr) :
        m_ptr(rptr.m_ptr), m_del(std::move(rptr.m_del)) {
        rptr.m_ptr = nullptr;
    }
    my_unique_ptr& operator=(my_unique_ptr&& rptr) noexcept {
        if (this != &rptr) {
            m_del(m_ptr);
            m_ptr = rptr.m_ptr;
            m_del = std::move(rptr.m_del);
            rptr.m_ptr = nullptr;
        }
        return *this;
    }

    //放弃指针的控制权
    T* release() {
        T* tmp = m_ptr;
        m_ptr = nullptr;
        return tmp;
    }

    /*
    u.reset()    释放指向的对象
    u.reset(q)   如果提供了内置指针q，就令u指向这个对象
    u.reset(nullptr)   将u置空
    */
    void reset() {
        m_del(m_ptr);
        m_ptr = nullptr;
    }
    void reset(T* ptr) {
        m_del(m_ptr);
        m_ptr = ptr;
    }
    void swap(my_unique_ptr& ptr) noexcept {
        std::swap(m_ptr, ptr.m_ptr);
        std::swap(m_del, ptr.m_del);
    }

    T* get() const { return m_ptr; }
    D& get_deleter() const { return m_del; }
    T& operator*() const { return *m_ptr; }
    T* operator->() const { return m_ptr; }
protected:
    T* m_ptr;
    D m_del;
};

测试代码：

void test_auto_ptr()
{
    cout << "******test_auto_ptr******" << endl;
    my_auto_ptr<int> m_data(new int(1));
    cout << *m_data << endl;
    
    my_auto_ptr<int> m_data1 = m_data;
    ++(*m_data1);
    cout << *m_data1 << endl;
    
    my_auto_ptr<int> m_data2(m_data1);
    ++(*m_data2);
    cout << *m_data2 << endl;

    my_auto_ptr<void> m_void;
}

void test_shared_ptr()
{
    cout << "******test_shared_ptr******" << endl;
    my_shared_ptr<int> m_data(new int(1));
    cout << *m_data << ",count:" << m_data.count() << endl;

    my_shared_ptr<int> m_data1 = m_data;
    ++(*m_data1);
    cout << *m_data << "," << *m_data1 << ",count:" << m_data.count() << endl;
    cout << "m_data 析构前 count:" << m_data.count() << endl;
    m_data.~my_shared_ptr();
    cout << "m_data 析构后 count:" << m_data.count() << endl;

    my_shared_ptr<int> m_data2(m_data1);
    ++(*m_data2);
    cout << *m_data << "," << *m_data1 << "," << *m_data2 << endl;

    my_shared_ptr<void> m_void;
}

void test_unique_ptr()
{
    cout << "******test_unique_ptr******" << endl;
    int* p1 = new int(1);
    my_unique_ptr<int> m_data(p1);
    cout << *m_data << endl;

    int* p2 = new int(2);
    m_data.reset();
    m_data.reset(p2);
    cout << *m_data << endl;

    my_unique_ptr<int> m_data2(new int(3));
    m_data.swap(m_data2);
    cout << *m_data << endl;
}