再识智能指针

最新推荐文章于 2024-05-27 15:59:37 发布

f2016913

最新推荐文章于 2024-05-27 15:59:37 发布

阅读量2.1k

点赞数 3

分类专栏： c++ 文章标签：智能指针管理

本文链接：https://blog.csdn.net/f2016913/article/details/75195948

版权

c++ 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

背景
为什么需要智能指针:
如果在程序中
这里写图片描述
这时我们希望有一个类来帮我们完成资源的管理,智能指针就出现了.
什么是智能指针?
分三步去理解
a:第一步:RAII:
又称资源分配即初始化,定义一个类来封装资源的分配和释放,在构造函数完成资源的分配和初始化,在析构函数完成资源的清理,可以保证资源的正确初始化和释放.
简单点说就是在初始化时获取系统的资源,在析构时,释放资源.

b:第二步:希望像指针一样,这时需要重载运算符来完成

T&operator*()
    {
        return *ptr;
    }
     //->箭头的好处
     //如果类型有很多,比如结构体,当我们希望访问一个具体的成员时,我们希望通过箭头来访问.
     T* operator->()
     {
         return _ptr;//返回对象
     }

c:第三步实现一个智能指针

1:第一种AoToPtr

class AutoPtr
{
public:
    AutoPtr(T*ptr)
        :_ptr(ptr)
    {}
    //解引用,取ptr的内容(如果不取引用的话,就是临时对象,是一个左值无法完成赋值,所以取引用)
     T&operator*()
    {
        return *_ptr;
    }
     //->箭头的好处
     //如果类型有很多,比如结构体,当我们希望访问一个具体的成员时,我们希望通过箭头来访问.

     //operator->(this)->成员   缺点是可读性比较差
     T* operator->()
     {
         return _ptr;//返回对象
     }

     //构造函数ap(ap1)
     AutoPtr(AutoPtr <T>&ap)
         :_ptr(ap._ptr)
     {
         delete ap._ptr;
     }
     //ap2 =ap1
     AutoPtr<T>&operator = (AutoPtr<T>&ap)
     {
         //考虑自赋值
         if (this !=&ap)
         {
             //将this指针所指的对象给释放,然后再赋值,记住永远要保证每次只管理一个对象
             delete _ptr;
             _ptr = NULL;
             _ptr = ap._ptr;
         }
     }
    ~AutoPtr()
    {
        delete _ptr;
    }
    //成员函数
    void Func(AutoPtr<T> ap)
    {
        cout << "Func()" << endl;
    }
private:
    T*_ptr;
};

void TestSmartPtr()
{

    AutoPtr<int> ap(new int(10));
    AutoPtr<int> ap1(new int(20));
    cout << (*ap) << endl;
    ap.Func(ap1);

}

这里写图片描述

为什们会出现这种情况呢?其实是一个Func函数参数是值传递是一个浅拷贝,此时ap和ap1两个对象都指向同一个内存,当调用析构函数,会析构两次
关于深浅拷贝在博客:http://blog.csdn.net/f2016913/article/details/55201534有所介绍在这里不多说.
此时小伙伴肯定想着既然浅拷贝不可以,那我们就来深拷贝,也不行,为什么?
首先要分清深拷贝是拥有了对象的,而智能指针呢?只是拥有管理权,所以是NO!

既然AutoPtr拷贝时候会出问题,那么我们如何解决?
第二种:ScopedPtr(防拷贝)

class ScopedPtr
{
public:
    ScopedPtr(ScopedPtr<T> ptr)
        :_ptr(ptr)
    {}
    //解引用
    T&operator*()
    {
        return *_ptr;
    }
    T*operator->()
    {
        return _ptr;//返回对象
    }
    ~ScopedPtr()
    {
        delete _ptr;
    }
private:
    //将构造和赋值函数定义成私有
    ScopedPtr(const ScopedPtr<T>&);
    ScopedPtr<T>operator =(const ScopedPtr<T>&);
private:
    T*_ptr;
};

ScopedPtr:防拷贝,简单粗暴.解决AuToPtr的缺陷.但是不能拷贝和赋值

第三种:SharedPtr(共享智能指针)
SharedPtr解决了智能指针共享空间的空间的所有权的问题,,那么拷贝和赋值的问题如何解决呢?

class SharedPtr
{
public:
    SharedPtr(T*ptr)
        :_ptr(ptr)
        , _RefCount(new int(1))//表明开始只有一个对象
    {}
    //拷贝构造
    SharedPtr(SharedPtr<T>&sp)
        :_ptr(sp._ptr)
        ,_RefCount(sp._RefCount)
    {
        ++(*_RefCount);

    }
    //赋值(sp1 =sp2)
    SharedPtr<T>&operator=(const SharedPtr<T>&sp)
    {
        //要解决两个问题:自赋值.以及如果赋值的sp2是sp1拷贝构造的呢?
        if (_ptr!=sp._ptr)
        {
            if (--(*_RefCount) == 0)//当只有之后一个对象时,释放资源(可能会有线程安全,最好是加锁或者原子操作)
            {
                delete _ptr;
                delete _RefCount;

            }
            _ptr = sp._ptr;
            _RefCount = sp._RefCount;
            ++(*_RefCount);//否则加加引用计数(可能会有线程安全,最好原子操作或者是加锁)
        }
        return *this;
    }
    T &operator*()
    {
        return *_ptr;
    }

    T*operator->()
    {
        return _ptr;
    }
    ~SharedPtr()
    {
        //当引用计数为0时,释放空间和引用计数
        if (--(*_RefCount) == 0)
        {
            delete _ptr;
            delete _RefCount;
        }
    }

private:
    T*_ptr;
    int *_RefCount;
};
void TestSmartPtr()
{
    SharedPtr<int> sp(new int(10));
    SharedPtr<int> sp1(sp);//拷贝构造
    SharedPtr<int> sp2= sp;//赋值运算符的重载
}

这里写图片描述
通过上面我们发现,在赋值和拷贝的时候,多个对象指向同一块资源,开始只有一个对象占有一个资源,引用计数是1,每增加一个对象指向自己,引用计数加加,前面我们也了解到当多个对象指向一个共同的空间时,析构会多次释放,就会造成内存泄露,而Shared_ptr是通过控制引用计数,来释放空间,当发现引用计数为0时,才会释放资源和引用计数指针.

循环引用
在说明循环引用之前,我们来复习下前面的知识,前面我们知道智能指针scoped_ptr,shared_ptr是c++库boost提供,C++11后来也参考了boost,所以今天我们用另外一种方法来添加智能指针.注意编辑器必须是2010以上的,否则还是无法编译.
这里写图片描述

我们来看一种情况:
#include<memory>
struct ListNode
{
    std::shared_ptr<ListNode>prev;
    std::shared_ptr<ListNode>next;


    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};
void TestSmartPtr()
{
    std::shared_ptr<ListNode>node1(new ListNode());
    std::shared_ptr<ListNode>node2(new ListNode());

    cout << "node1.count()?" << node1.use_count() << endl;
    cout << "node2.count()?" << node2.use_count() << endl;

    node1->next = node2;
    node2->prev = node1;

    cout << "node1.count()?" << node1.use_count() << endl;
    cout << "node2.count()?" << node2.use_count() << endl;

}

这里写图片描述
1:此时有两个对象node1和node2的prev管理node1的空间,也有两个对象node2和node1的next管理node2的对象,这就是我们常说的循环引用计数的问题.我们再通过图形来仔细分析:

2:我们可以分为两层来说明:
第一层:每个空间都有两个对象来管理这个空间,如node1的对象有两个智能指针去管理一个是node1,另一个是node2的prev
node2的对象也有两个智能指针去管理,一个是node2,一个是node1的next;
第二层:出了作用域,就会掉析构函数.此时node1的释放由node2的prev决定,而node2的释放由node的next.
可能这样我们还是不太明白,我们再从细节来分析:首先node2对象的释放依赖于next(node对象的next),而next的释放依赖于node1对象,node1对象依赖于prev(node2对象的prev),而prev是释放依赖于node2.
这里写图片描述
3:这样我们也许就会解释为什么第二次的引用计数是2,以及为什么不会调析构函数了.
那么如何解决循环引用的问题呢?
我们需要第四种智能指针,weak_ptr

struct ListNode
{

    std::weak_ptr<ListNode>prev;
    std::weak_ptr<ListNode>next;

    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};
void TestSmartPtr()
{
    std::shared_ptr<ListNode>node1(new ListNode());
    std::shared_ptr<ListNode>node2(new ListNode());

    cout << "node1.count()?" << node1.use_count() << endl;
    cout << "node2.count()?" << node2.use_count() << endl;

    node1->next = node2;
    node2->prev = node1;

    cout << "node1.count()?" << node1.use_count() << endl;
    cout << "node2.count()?" << node2.use_count() << endl;

}

这里写图片描述
这时我们发现引用计数此时为1,而且也会调用析构函数.
weak_ptr:使两个智能指针指向不同的空间,原理是不增加引用计数.
注意:weak_ptr不能单独使用必须和shared_ptr一起使用.
当然还有一种方法是通过仿函数设置定制删除器,来打破循环引用.关于定制删除器的方法,有兴趣可以自己研究下.

通过上面我们再次总结一些智能指针
1:AutoPtr:缺陷设计,只是一种管理权转移的智能指针.
2:ScopedPtr:简单粗暴,防拷贝
3:SharedPtr:功能强大,结构复杂,但是会存在线程安全的问题,以及循环引用的问题.
4:WeakPtr:不能单独使用,必须和sharedptr一起使用,主要是为了解决循环引用的问题.

当然智能指针还有许多内容,比如scoped_ptr的线程安全的问题等等,需要在后面再慢慢研究.

本文参考了以前的博客:智能指针:http://blog.csdn.net/f2016913/article/details/56666732