智能指针之shared_ptr和unique_ptr实现

#include <iostream>
#include <string>
using namespace std;
 
class Delete
{
public:
    template <typename T>
    void operator()(T *p) const
    {
        delete p;
    }
};
template <typename T, typename D = Delete>
class unique_ptr
{
public:
    explicit unique_ptr(T *pp = nullptr, const D &dd = D())
        : un_ptr(pp), del(dd)
    {
    }
    ~unique_ptr()
    {
        del(un_ptr);
    }
    /* 不支持拷贝与赋值   */
    unique_ptr(const unique_ptr &) = delete;
    unique_ptr &operator=(const unique_ptr &) = delete;
 
    /*可以拷贝或者赋值一个将要被销毁的 unique_ptr（右值引用）*/
    unique_ptr(unique_ptr &&right_value) : un_ptr(right_value.un_ptr), del(std::move(right_value.del))
    {
        right_value.un_ptr = nullptr;
    }
    unique_ptr &operator=(unique_ptr &&right_value) noexcept
    {
        if (this != &right_value)
        {
            std::cout << "operator && right_value " << std::endl;
            del(*this);
            un_ptr = right_value.un_ptr;
            del = std::move(right_value.del);
            right_value.un_ptr = nullptr;
        }
        return *this;
    }
    //u.release()   u 放弃对指针的控制权，返回指针，并将 u 置为空
    T *release()
    {
        T *tmp = un_ptr;
        un_ptr = nullptr;
        return tmp;
    }
    /*
    u.reset()   释放u指向的对象
    u.reset(q)  如果提供了内置指针q，就令u指向这个对象
    u.reset(nullptr) 将 u 置为空
    */
    void reset() { del(un_ptr); }
    void reset(T *q)
    {
        if (un_ptr)
        {
            del(un_ptr);
            un_ptr = q;
        }
        else
            un_ptr = nullptr;
    }
    void swap(unique_ptr &other) noexcept
    {
        using std::swap;
        swap(un_ptr, other.un_ptr);
        swap(del, other.del);
    }
    T *get() { return un_ptr; }
    D &get_deleter() { return del; }
    T &operator*() { return *un_ptr; }
    T *operator->() { return un_ptr; }
 
private:
    T *un_ptr = nullptr;
    D del;
};
 
struct Foo
{
    Foo() { std::cout << "Foo()\n"; }
    ~Foo() { std::cout << "~Foo()\n"; }
    Foo(const Foo &) { std::cout << "Foo copy ctor\n"; }
    Foo(Foo &&) { std::cout << "Foo move ctor\n"; }
};
struct Fooo
{
    Fooo(int n = 0) noexcept : bar(n) { std::cout << "Fooo: constructor, bar = " << bar << '\n'; }
    ~Fooo() { std::cout << "Fooo: destructor, bar = " << bar << '\n'; }
    int GetBar() const noexcept { return bar; }
 
private:
    int bar;
};
struct D
{
    void bar() { std::cout << "Call deleter D::bar()...\n"; }
    void operator()(Foo *p) const
    {
        std::cout << "Call delete from function object...\n";
        delete p;
    }
};
 
int main()
{
    unique_ptr<string> p1(new string("my_unique_ptr"));
    cout << *p1 << endl;
    {
        std::cout << "======================\nunique_ptr constructor:\n";
        unique_ptr<Foo> up1;
        unique_ptr<Foo> up1b(nullptr);
        unique_ptr<Foo> up2(new Foo);
 
        Delete d;
        unique_ptr<Foo, Delete> up3(new Foo, d);
        unique_ptr<Foo, Delete &> up3b(new Foo, d);
        unique_ptr<Foo, Delete> up4(new Foo, Delete());
        unique_ptr<Foo> up5b(std::move(up2));
        unique_ptr<Foo, Delete> up6b(std::move(up3));
 
        unique_ptr<Foo> up7 = std::move(up5b);
        Foo *fp = up7.release();
        delete fp;
 
        up6b.reset(new Foo());
        up6b.reset(nullptr);
 
        unique_ptr<Fooo> up71(new Fooo(1));
        unique_ptr<Fooo> up72(new Fooo(2));
 
        up71.swap(up72);
 
        std::cout << "up71->val:" << up71->GetBar() << std::endl;
        std::cout << "up72->val:" << (up72.get())->GetBar() << std::endl;
 
        unique_ptr<Foo, D> up8(new Foo(), D());
        D &del = up8.get_deleter();
        del.bar();
    }
}

template<typename T>
class sharedptr {
public:
    //构造函数
    sharedptr(T *ptr):_ptr(ptr),_cnt(new int(1)) {
        cout << "构造" << endl;
    }
    //拷贝构造
    sharedptr(sharedptr<T> sp):_ptr(sp._ptr),_cnt(sp._cnt){
        cout << "拷贝构造" << endl;
        ++(*_cnt);
    }
    //赋值操作运算符
    sharedptr<T> operator=(sharedptr<T> sp) {
        cout << "赋值操作运算符" << endl;
        if (_ptr != sp._ptr) {
            if (--(*_cnt) == 0) {//计数器为0，则释放指针指向的对象
                delete _ptr;
                delete _cnt;
 
            }
            _ptr = sp._ptr;
            _cnt = sp._cnt;
            ++(*_cnt);
 
        }
        return *this;
    }
    T * operator->() {
        return _ptr;
    }
    T& operator*() {
        return *_ptr;
    }
    int getcnt() {
        return *_cnt;
    }
    ~sharedptr(){
        cout << "析构" << endl;
        if (--(*cnt) == 0) {
            delete _ptr;
            _ptr = nullptr;
            delete _cnt;
            _cnt = nullptr;
        }
    }
private:
    int *_cnt;
    T *_ptr;
};