C++智能指针(二)：模拟实现三种智能指针

上一篇博客我们简单介绍了智能指针：简单介绍智能指针

有关shared_ptr的循环引用问题可以参考博客：weak_ptr–解决shared_ptr循环引用问题

auto_ptr

模拟实现

template<class T>
class Autoptr
{
public:
    Autoptr(T* ptr = NULL)
        :_ptr(ptr)
    {}

    Autoptr(Autoptr<T>& ap)
    {
        _ptr = ap._ptr;
        ap._ptr = NULL;
    }

    Autoptr<T>& operator=(Autoptr<T>& ap)
    {
        if (this != &ap)
        {
            delete _ptr;
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }

        return *this;
    }

    T* operator->()
    {
        return _ptr;
    }

    T operator*()
    {
        return *_ptr;
    }

    ~Autoptr()
    {
        delete _ptr;
        _ptr = NULL;
    }

    void Reset(T* ptr = 0)
    {
        if (_ptr != ptr)
        {
            delete _ptr;
        }
        _ptr = ptr;
    }
protected:
    T* _ptr;
};

void APTest()
{
    Autoptr<int> ap1(new int(10));
    cout <<"*ap1 = "<< *ap1 << endl;

    Autoptr<int> ap2(ap1);
    cout <<"*ap2 = "<< *ap2 << endl;

    Autoptr<int> ap3(new int(20));
    ap3 = ap2;
    cout <<"*ap3 = "<< *ap3 << endl;

    //cout << *ap1 << endl;//报错
}

测试结果：

代码分析

代码中的Reset()函数是干嘛的？

void Reset(T* ptr = 0)
    {
        if (_ptr != ptr)
        {
            delete _ptr;
        }
        _ptr = ptr;
    }

答：为了重置一个auto_ptr对象，必须使用reset()函数。可以向reset()传递一个指针，如果不希望设置该auto_ptr对象的话，可以传递一个0值。如果auto_ptr当前指向一个对象并且该auto_ptr对象拥有该对象的所有权，则该对象再底层指针重置之前，首先被删除。例如：

void APTest()
{
    int *pi = new int(20);
    auto_ptr<int>_auto_ptr(pi);
    cout << "_auto_ptr = " << *pi << endl;

    int *pi2 = new int(30);
    _auto_ptr.reset(pi2);
    cout << "pi->" << *pi << endl;
    cout << "pi2->" << *pi2 << endl;
}

输出结果：

我们可以在输出结果的第二行看到，pi已经变成了随机值。reset()函数将auto_ptr对象原来指向的那块动态分配的空间释放了。

上面的代码还有一句：

//cout << *ap1 << endl;//报错

为什么报错？？
这是因为ap1已经把它指向的空间交给了ap2去管理，所以ap1已经不具备访问原来自己所指向的空间的权限。所以对它进行解引用是非法的。
所以可以看清auto_ptr的本质是管理权的转移，即ap1将自己所指向的空间交给ap2来管理，析构也是由ap2来完成。

scoped_ptr

由于auto_ptr的严重缺陷，所以后来引入了scoped_ptr。防拷贝，意思就是不能进行拷贝，简单地说是一种简单粗暴的方式。

模拟实现

template<class T>
class  Scopedptr
{
public:
    Scopedptr(T* ptr = NULL)
        :_ptr(ptr)
    {}

    T* operator->()
    {
        return _ptr;
    }

    T operator*()
    {
        return *_ptr;
    }

    ~Scopedptr()
    {
        delete _ptr;
        _ptr = NULL;
    }

protected:
    Scopedptr(Scopedptr<T>& sp);
    Scopedptr<T>& operator=(const Scopedptr<T>& p);
private:
    T* _ptr;
};

void SPTest()
{
    Scopedptr<int> sp(new int(10));
    cout << "sp = " << *sp << endl;
}

scoped_ptr中对拷贝构造函数和赋值运算符的重载函数只是进行了声明，并没有去定义这两个函数，而且声明为protected或者是private，这是防止别人在类外对这两个函数进行定义。防止拷贝，所以说scope_dptr是一种简单粗暴的方式。

shared_ptr

编写程序往往要用到拷贝，这样scopedptr就不能起到相应的作用，所以便有了shared_ptr。
shared_ptr->采用了引用计数，优点是功能强大，但是也有缺点，缺点是过于复杂，而且会引起循环引用。

template<class T>
class Sharedptr
{
public:
    Sharedptr(T* ptr = NULL)
        :_ptr(ptr)
        , pcount(0)
    {
        if (_ptr != NULL)
            pcount = new int(1);
    }

    Sharedptr(const Sharedptr<T>& sp)
    {
        _ptr = sp._ptr;
        pcount = sp.pcount;
        ++(*pcount);
    }

    Sharedptr<T>& operator=(const Sharedptr<T>& sp)
    {
        if (this != &sp)
        {
            if (_ptr && --(*pcount) == 0)
            {
                delete pcount;
                delete _ptr;
            }
            pcount = sp.pcount;
            _ptr = sp._ptr;
            ++(*pcount);
        }

        return *this;
    }

    ~Sharedptr()
    {
        if (_ptr && --(*pcount) == 0)
        {
            delete _ptr;
            delete pcount;
        }
    }

    T& operator*()
    {
        return *_ptr;
    }

    T* operator->()
    {
        return _ptr;
    }

    T Getpcount()
    {
        return *(pcount);
    }

    void Realease()
    {
        if (--(*pcount) == 0)
        {
            delete _pcount;
            delete _ptr;
        }
    }

    void Reset(T* ptr, int* pcount)
    {
        if (_ptr != ptr)
        {
            delete _ptr;
            delete _pcount;
        }

        _ptr = ptr;
        _pcount = pcount;
    }
private:
    T* _ptr;
    T* pcount;
};

void Test()
{
    Sharedptr<int> s1(new int(10));
    cout << "s1 = " << *s1 << endl;
    cout << "pcount = " << s1.Getpcount() << endl;

    Sharedptr<int> s2(s1);
    cout << "s2 = " << *s2 << endl;
    cout << "pcount = " << s2.Getpcount() << endl;

    Sharedptr<int> s3;
    s3 = s1;
    cout << "s3 = " << *s3 << endl;
    cout << "pcount = " << s3.Getpcount() << endl;
}

测试结果：