auto_ptr和shared

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

auto_ptr的实现：

template <class T>

class auto_ptr

{

private:

    T *ptr;

public:

    explicit auto_ptr(T *p = ) : 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 = ;

        return tmp;

    }

    void reset(T *p = )

    {

        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 = ) : ptr(p), count(new int()) {}

    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 == )

        {

            delete ptr;

            delete count;

        }

    }

};

参考资料：

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

shared_ptr缺点：

存在环状引用问题。

巴特西

auto_ptr和shared_ptr

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

最新文章

热门文章