auto_ptr和shared_ptr

　　《Effective C++》在资源管理一节提到了智能指针，智能指针中最著名的当属auto_ptr和shared_ptr。本文主要研究两者的实现。

auto_ptr的实现：

template <class T>
class auto_ptr
{
private:
    T *ptr;
public:
    explicit auto_ptr(T *p = 0) : ptr(p){}
    ~auto_ptr(){delete ptr;}
    auto_ptr(auto_ptr &rhs) : ptr(rhs.release()){}
    auto_ptr& operator=(auto_ptr &rhs)
    {
        reset(rhs.release());
        return *this;
    }
    T& operator*() const {return *ptr;}
    T* operator->() const {return ptr;}
    T* get() const {return ptr;}
    T* release()
    {
        T *tmp = ptr;
        ptr = 0;
        return tmp;
    }
    void reset(T *p = 0)
    {
        if (p != ptr)
        {
            delete ptr;
            ptr = p;
        }
    }
};

参考资料：https://gcc.gnu.org/onlinedocs/gcc-4.6.3/libstdc++/api/a00761_source.html

auto_ptr的缺点：

　　1. 复制或赋值行为不正常，因此不能置于容器中。

　　2. 不能用于管理动态分配的数组。

    shared_ptr通过reference counting实现，这里有个简易版本。

template <class T>
class countedPtr {
private:
    T *ptr;
    int *count;
public:
    explicit countedPtr(T *p = 0) : ptr(p), count(new int(1)) {}
    countedPtr(const countedPtr &rhs) : ptr(rhs.ptr), count(rhs.count) 
    {
        ++*count;
    }
    ~countedPtr()
    {
        dispose();
    }
    countedPtr& operator=(const countedPtr &rhs)
    {
        if (this != &rhs)
        {
            dispose();
            ptr = rhs.ptr;
            count = rhs.count;
            ++*count;
        }
        return *this;
    }
    T& operator*() { return *ptr; }
    T* operator->() { return ptr; }
private:
    void dispose() 
    {
        if (--*count == 0)
        {
            delete ptr;
            delete count;
        }
    }
};

参考资料：

引用计数智能指针的简单实现

shared_ptr缺点：

    存在环状引用问题。