智能指针——unique_ptr的原理及仿写

unique_ptr的原理及仿写

• 独占指针只允许有一份指针指向这份数据,不能将同一个裸指针赋值给多个智能指针
• 也就是在这个模板类里面，拷贝构造和拷贝赋值函数都被删除了，不允许调用，智能移动构造和移动赋值
• 独占指针不允许隐式构造
• 提供了bool运算符重载
• 释放内存使用的是deleter（删除器），里面会判断delete或者delete[]

template<class T>
class MyUnique_ptr {
private:
    //私有的内部实际指针
    T* m_ptr;
public:
    //以裸指针构造独占指针，默认为nullptr
    //禁止隐式构造
    explicit MyUnique_ptr(T* ptr = nullptr) : m_ptr(ptr) { 
        ptr = nullptr;
    }
    //因为独占指针只允许有一个指针占有实际内存
    //因此删除拷贝构造和拷贝赋值函数
    MyUnique_ptr(const MyUnique_ptr& src) = delete; 
    MyUnique_ptr& operator=(MyUnique_ptr& src) = delete;
    //移动构造函数
    MyUnique_ptr(MyUnique_ptr&& src) {
        m_ptr = src.m_ptr;
        src.m_ptr = nullptr;
    }
    //移动赋值函数
    MyUnique_ptr& operator=(MyUnique_ptr&& src) {
        if (&src == this) return *this;
        m_ptr = src.m_ptr;
        src.m_ptr = nullptr;
        return *this;
    }
    //析构函数，释放指针
    ~MyUnique_ptr() {
        delete m_ptr;
        m_ptr = nullptr;
    }
    //返回内部指针地址
    T* get() {
        return m_ptr;
    }
    //销毁独占指针，取出裸指针
    T* release() {
        T* ptr = m_ptr;
        m_ptr = nullptr;
        return ptr;
    }
    //重置独占指针
    void reset(T* ptr = nullptr) {
        delete m_ptr;
        m_ptr = ptr;
        ptr = nullptr;
    }
    //交换两个指针，成员函数
    void swap(MyUnique_ptr<T>& src) {
        T* temp;
        temp = src.m_ptr;
        src.m_ptr = m_ptr;
        m_ptr = temp;
    }
    //重载*
    T& operator*() const {
        return *m_ptr;
    }
    //重载->
    T* operator->() const {
        return (&**this);
    }
    //转换函数，重载bool，用在if(u_ptr){}
    operator bool() const {
        return m_ptr != nullptr;
    }
    //声明友元函数
    template<class U>
    friend void swap(MyUnique_ptr<U>& a, MyUnique_ptr<U>& b);
};
//全局函数，用指针make_MyUnique
template<class T>
MyUnique_ptr<T> make_MyUnique(T* ptr = nullptr) {
    return MyUnique_ptr<T>(ptr);
}
//全局函数，有右值引用make_MyUnique
template<class T>
MyUnique_ptr<T> make_MyUnique(MyUnique_ptr<T>&& src) {
    return MyUnique_ptr<T>(forward<MyUnique_ptr<T>>(src));
}
//交换两个独占指针,全局函数
template<class T>
void swap(MyUnique_ptr<T>& a, MyUnique_ptr<T>& b) {
    T* temp;
    temp = a.m_ptr;
    a.m_ptr = b.m_ptr;
    b.m_ptr = temp;
}