复习RAII（智能指针）

最新推荐文章于 2023-10-29 00:47:00 发布

一个字节

最新推荐文章于 2023-10-29 00:47:00 发布

阅读量786

点赞数

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

本文链接：https://blog.csdn.net/wy1550365215/article/details/77619622

版权

c++ 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

一、什么是RAII

RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。

RAII又叫做资源分配即初始化，即：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。

二、为什么要使用

在计算机系统中，资源是数量有限且对系统正常运行具有一定作用的元素。比如：网络套接字、互斥锁、文件句柄和内存等等，它们属于系统资源。由于系统的资源是有限的，所以，我们在编程使用系统资源时，都必须遵循一个步骤：
申请资源；
使用资源；
释放资源。
第一步和第三步缺一不可，因为资源必须要申请才能使用的，使用完成以后，必须要释放，如果不释放的话，就会造成资源泄漏。

所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放。它是一个类，有类似指针的功能。

举个栗子：

void Func()  
{  
  FILE *fp;  
  char* filename = "test.txt";  
  if((fp=fopen(filename,"r"))==NULL)  
  {  
      printf("not open");  
      exit(0);  
  }  
  ... // 如果 在使用fp指针时产生异常 并退出  
       // 那么 fp文件就没有正常关闭  

  fclose(fp);  
}

在资源的获取到释放之间，我们往往需要使用资源，但常常一些不可预计的异常是在使用过程中产生，就会使资源的释放环节没有得到执行。

此时，就可以让RAII惯用法大显身手了。

RAII的实现原理很简单，利用stack上的临时对象生命期是程序自动管理的这一特点，将我们的资源释放操作封装在一个临时对象中。

示例：

class Resource{};  
class RAII{  
public:  
    RAII(Resource* aResource):r_(aResource){} //获取资源  
    ~RAII() {delete r_;} //释放资源  
    Resource* get()    {return r_ ;} //访问资源  
private:  
    Resource* r_;  
};

比如文件操作的例子，我们使用RAII可以写成：

class FileRAII{  
public:  
    FileRAII(FILE* aFile):file_(aFile){}  
    ~FileRAII() { fclose(file_); }//在析构函数中进行文件关闭  
    FILE* get() {return file_;}  
private:  
    FILE* file_;  
};

void Func()  
{  
  FILE *fp;  
  char* filename = "test.txt";  
  if((fp=fopen(filename,"r"))==NULL)  
  {  
      printf("not open");  
      exit(0);  
  }  
  FileRAII fileRAII(fp);  
  ... // 如果 在使用fp指针时产生异常 并退出  
       // 那么 fileRAII在栈展开过程中会被自动释放，析构函数也就会自动地将fp关闭  

  // 即使所有代码是都正确执行了，也无需手动释放fp，fileRAII它的生命期在此结束时，它的析构函数会自动执行！      
 }

优点：免除了对需要谨慎使用资源时而产生的大量维护的代码。在保证资源正确处理的情况下，还提高了代码的可读性。

　智能指针(smart pointer)的通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。每次创建类的新对象时，初始化指针就将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

常见的智能指针：

std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost::intrusive_ptr

auto_ptr 特点：独占所有权，转移所有权。

第一种实现：最开始auto_ptr的成员变量主要有T* _ptr 和 bool _owner,主要实现原理是在构造对象时赋予其管理空间的所有权，在拷贝或赋值中转移空间的所有权，在析构函数中当_owner为true（拥有所有权）时来释放所有权。

template<typename T>
class AutoPtr
{
public:
    //构造函数
    explicit AutoPtr(T* ptr = NULL)
        :_ptr(ptr)
        , _owner(true)
    {}
    //拷贝构造
    AutoPtr(AutoPtr<T>& ap) //参数不能写成const的，这里要修改ap对象的成员    :_ptr(ap._ptr)
        , _owner(true)
    {
        ap._owner = false;  //转让权限
    }
    //赋值运算符重载
    AutoPtr& operator=(AutoPtr<T>& ap)
    {
        if (this！ = &ap)
        {
            delete this->_ptr;
            this->_ptr = ap._ptr;
            // 转让权限
            this->_owner = true;
            ap._owner = false;
        }
        return *this;
    }
    //析构函数
    ~AutoPtr()
    {
        // 只删除拥有权限的指针
        if (_owner)
        {
            this->_owner = false;
            delete this->_ptr;
        }
    }

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

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

    T* AutoPtr<T>::GetStr()
    {
        return (this->_ptr);
    }
protected:
    T* _ptr;
    bool _owner; //权限拥有者
};

　出现的主要问题：如果拷贝出来的对象比原来的对象先出作用域或先调用析构函数，则原来的对象的_owner虽然为false，但却在访问一块已经释放的空间，原因在于拷贝对象的释放会导致原对象的_ptr指向的内容跟着被释放！

问题体现如下：

ap1将析构的权限给予了ap2,由于ap1._ptr和ap2._ptr指向同一份空间，ap2在出了if作用域之后自动被释放，进而导致ap1._ptr也被释放。

但是在if作用域之外，又对ap1._ptr进行访问，导致程序崩溃，这时候 ap1._ptr已经是一个野指针了，这就造成指针的悬挂的问题！

void Test()
{
AutoPtr ap1(new int(1));
if (true)
{
AutoPtr ap2(ap1);
}

    //这里的ap1._ptr已经是一个野指针了，这就造成指针的悬挂的问题
    *(ap1.GetStr() )= 10;

}
　　auto_ptr的第二种实现方法：还是管理空间的所有权转移，但这种实现方法中没有_owner权限拥有者。构造和析构和上述实现方法类似，但拷贝和赋值后直接将_ptr赋为空，禁止其再次访问原来的内存空间,比较简单粗暴。

template<typename T>
class AutoPtr
{
public:
    //构造函数
    explicit AutoPtr(T* ptr = NULL)  //不能写成const T* ptr，否则出现const类型赋值给非const类型的问题
        :_ptr(ptr)
    {}
    //拷贝构造
    AutoPtr(AutoPtr<T>& ap)
        :_ptr(ap._ptr)
    {
        ap._ptr=NULL; 
    }
    //赋值运算符重载
    AutoPtr& operator=(AutoPtr<T>& ap)
    {
        if (this！ = &ap)
        {
            delete this->_ptr;
            this->_ptr = ap._ptr;
            ap._ptr = NULL;
        }
        return *this;
    }
    //析构函数
    ~AutoPtr()
    {
        // 只删除拥有权限的指针
        if (_ptr)
        {
            delete _ptr;
        }
    }

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

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

    T* GetStr()
    {
        return _ptr;
    }
protected:
    T* _ptr;
};

　　这种实现方式很好的解决了旧版本野指针问题，但是由于它实现了完全的权限转移，所以导致在拷贝构造和赋值之后只有一个指针可以使用，而其他指针都置为NULL,使用很不方便，而且还很容易对NULL指针进行解引用，导致程序崩溃，其危害也是比较大的。

一般建议不要使用auto_ptr!!!

scoped_ptr 特点：独占所有权，防拷贝。

scoped_ptr的实现原理是防止对象间的拷贝与赋值，具体事项是将拷贝构造函数和赋值运算符函数设置为保护或者私有的，并且只声明不实现，并将标志设置为保护或私有的防止他人在类外拷贝，简单粗暴，提高了代码的安全性。

template <class T>
class scoped_ptr
{

public:
    scoped_ptr(T* ptr == NULL)
    :_ptr(ptr)
    {}

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

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

    T* Get()
    {
        return _ptr;
    }
    ~scoped_ptr()
    {
        if(_ptr)
        {
            delete _ptr;
        }
    }

protected；
    scoped_ptr(const scoped_ptr<T>&);
    scoped_ptr& operator=(const scoped_ptr<T>&);
private:
    T* _ptr;
};

coped_ptr的实现和auto_ptr非常类似，不同的是 scoped_ptr有着更严格的使用限制——不能拷贝，这就意味着scoped_ptr 是不能转换其所有权的。

在一般的情况下，如果不需要对于指针的内容进行拷贝，赋值操作，而只是为了防止内存泄漏的发生，scoped_ptr完全可以胜任。

shared_ptr 特点：共享所有权，引用计数

shared_ptr的实现原理是通过引用计数来实现，拷贝或赋值时将引用计数加1，析构时只有当引用计数减到0才释放空间，否则只需将引用计数减1即可.

（ps:shared_ptr在新的C++11标准中叫做unique_ptr）

template <class T>
class SharedPtr
{
public:
    SharedPtr(T* ptr == NULL)
    :_ptr(ptr)
    ,_refCount(new long(1))
    {}

    //拷贝构造
    SharedPtr(const SharedPtr<T>& sp)
    :_ptr(sp._ptr)
    ,_refCount(sp._refCount)
    {
        ++(*_refCount);
    }

    //传统写法
    SharedPtr<T>& operator=(const SharedPtr<T>& sp)
    {
        if(this != &sp)
        {
            tihs->Release();
            _ptr = sp._ptr;
            _refCount = sp._refCount;
            ++(*_refCount);
        }
        return *this;
    }

    SharedPtr<T>& operator=(SharedPtr<T> sp)
    {
        swap(_ptr,sp._ptr);
        swap(_refCount,sp._refCount);

        return *this;
    }

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

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

    T* GetPtr()
    {
        return _ptr;
    }

    long GetCount()
    {
        return *_refCount;
    }


    ~SharedPtr()
    {
        Release();
    }

protected:
    void Release()
    {
        if(--(*_refCount) == 0)
        {
            delete _ptr;
            _ptr = NULL;
            delete _refCount;
        }
    }

private:
    T* _ptr;
    long* _refCount;
};

为什么引用计数要设置为指针类型，而不设置成整形或静态变量？
请看这篇文章：写时拷贝
有时候看似完美的东西，往往都存在着隐含的缺陷，上面的实现仍旧存在问题！

问题如下：

1、在多线程环境下，引用计数的更新存在安全隐患
2、循环引用问题
3、定制删除器
第一个比较容易理解，我们可以在改变引用计数的时候加上一把互斥锁，防止多线程带来的隐患。

第二个，循环引用问题。我们先来看一段利用标准库的shared_ptr 实现的代码：

//标准库的shared_ptr实现代码
#include <iostrream>
using namespace std;
#inclue <memory>

struct Node
{
    Shared_ptr<Node> _prev;
    Shared_ptr<Node> _next;

    ~Node()
    {
        cout<<"delet :"<<this<<endl;
    }
}

void Testsharedptr()
{
    Shared_ptr<Node> cur(new(Node));
    Shared_ptr<Node> next(new(Node));

}

结果：

这里写图片描述
cur和next出了作用域，都调用析构函数被释放了。看似正确，但是如果我们加两句代码，问题就出现了：

void TestSharedPtr()
{
    shared_ptr<Node> cur(new(Node));
    shared_ptr<Node> next(new(Node));
    cur->_next = next;    // 1
    next->_prev = cur;    // 2

这里写图片描述
我们发现两个节点都没有被释放！我们来分析一下原因：加了这两句代码后，这两个节点的引用计数都增加了1。出了作用域进行析构时，两个对象均不能释放，因为prev的要释放的前提是next释放，而next的释放又依赖于prev的释放。最后就形成了循环引用，谁都释放不了。

这里写图片描述

解决方案：使用weak_ptr

class Node
{
public:
    ~Node()
    {
        cout << "delete" << this << endl;
    }
public:
    weak_ptr<Node> _prev;
    weak_ptr<Node> _next;
};
void test()
{
    shared_ptr<Node> cur(new Node());
    shared_ptr<Node> next(new Node());

    cout << "连接前" << endl;
    cout << "cur" << cur.use_count() << endl;
    cout << "next" << cur.use_count() << endl;

    cur->_next = next;
    next->_prev = cur;

    cout << "连接后" << endl;
    cout << "cur" << cur.use_count() << endl;
    cout << "next" << next.use_count() << endl;
}

int main()
{
    test();
    cin.get();
    return 0;
}

结果：
这里写图片描述

因为weak_ptr（弱引用智能指针）会对引用计数会做特殊处理(上述情况不加1)。

定制删除器

在shared_ptr中只能处理释放new开辟的空间，而对于malloc，以及fopen打开的文件指针不能处理，所以提出了定制删除器，方便释放其他类型的指针，而其实现则是通过仿函数（通过重载operator()）来实现。

code:

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>
using namespace std;

template <class T,class Deleter = Del<T>>
class SharedPtr
{
public:
    SharedPtr(T *ptr);
    SharedPtr(T* ptr, Deleter del);
    SharedPtr(const SharedPtr<T, Deleter>& ap);
    ~SharedPtr();
    //赋值运算符重载使用现代写法
    SharedPtr<T, Deleter>& operator=(SharedPtr<T, Deleter> ap);
    T& operator*()const;
    T* operator->()const;
    long GetrefCount()const;
    T* GetPtr()const;
protected:
    void _Realease();
private:
    T* _ptr;
    long* _refCount;
    Deleter _del;
};

template <class T,class Deleter = Del<T>>
SharedPtr<T, Deleter>::SharedPtr(T* ptr)
:_ptr(ptr)
, _refCount(new long(1))
{}

template <class T,class Deleter = Del<T>>
SharedPtr<T, Deleter>::SharedPtr(T* ptr, Deleter del)
: _ptr(ptr)
, _refCount(new long(1))
, _del(del)
{}

template <class T,class Deleter = Del<T>>
SharedPtr<T, Deleter>::SharedPtr(const SharedPtr<T, Deleter>& ap)
:_ptr(ap._ptr)
, _refCount(ap._refCount)
, _del(ap._del)
{
    ++(*this->_refCount);
}

template <class T,class Deleter = Del<T>>
SharedPtr<T, Deleter>::~SharedPtr()
{
    this->_Realease();
}

//现代写法
template <class T,class Deleter = Del<T>>
SharedPtr<T, Deleter>& SharedPtr<T, Deleter>::operator=(SharedPtr<T, Deleter> ap)
{
    swap(this->_ptr, ap._ptr);
    swap(this->_refCount, ap._refCount);
    swap(this->_del, ap._del);
    return *this;
}

template <class T,class Deleter = Del<T>>
T& SharedPtr<T, Deleter>::operator*()const
{
    return *(this->_ptr);
}

template <class T, class Deleter = Del<T>>
T* SharedPtr<T, Deleter>::operator->()const
{
    return this->_ptr;
}

template <class T, class Deleter = Del<T>>
long SharedPtr<T, Deleter>::GetrefCount()const
{
    return *(this->_refCount);
}

template <class T, class Deleter = Del<T>>
T* SharedPtr<T, Deleter>::GetPtr()const
{
    return this->_ptr;
}

template <class T, class Deleter = Del<T>>
void SharedPtr<T, Deleter>::_Realease()
{
    if (--(*this->_refCount) == 0)
    {
        _del(_ptr);
            delete this->_refCount;
    }
}
//仿函数事项定制删除器
template <class T>
struct Free
{
    void operator()(T* ptr)
    {
        cout << "Free :" << ptr << endl;
        free(ptr);
    }
};

template <class T>
struct Fclose
{
    void operator()(T* ptr)
    {
        cout << "fclose :" << ptr << endl;
        fclose(ptr);
    }
};

template <class T>
struct Del
{
    void operator()(T* ptr)
    {
        cout << "delete :" << ptr << endl;
        delete (ptr);
    }
};

//测试
void testDeleter()
{
    int *p1 = (int*)malloc(sizeof(int));
    SharedPtr<int, Free<int>> sp1(p1);

    FILE* p2 = fopen("test.txt", "w");
    SharedPtr<FILE, Fclose<FILE>> sp2(p2);

    SharedPtr<int> sp3(new int(1));
}

class Node
{
public:
    ~Node()
    {
        cout << "delete" << this << endl;
    }
public:
    weak_ptr<Node> _prev;
    weak_ptr<Node> _next;
};
void test()
{
    shared_ptr<Node> cur(new Node());
    shared_ptr<Node> next(new Node());

    cout << "连接前" << endl;
    cout << "cur" << cur.use_count() << endl;
    cout << "next" << cur.use_count() << endl;

    cur->_next = next;
    next->_prev = cur;

    cout << "连接后" << endl;
    cout << "cur" << cur.use_count() << endl;
    cout << "next" << next.use_count() << endl;
}

int main()
{
    //test();
    testDeleter();
    cin.get();
    return 0;
}

这里写图片描述

总结：

auto_ptr 管理权的转移 ->不建议使用

scopd_ptr ( unique_ptr ) 防拷贝 ->简单粗暴

shared_ptr 引用计数 ->增减引用计数，直到对象的引用计数为0时再释放

scoped_array 和 shared_array 管理对象数组，由于scopd_ptr 和 scoped_array、shared_ptr 和 shared_array 的实现都比较类似，这里不再赘述。需要注意的是这两种机制都重载了operator[] .

week_ptr 弱指针 ->辅助shared_ptr解决循环引用的问题。

一个字节

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
复习RAII（智能指针）

一、什么是RAIIRAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。RAII又叫做资源分配即初始化，即：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。二、为什么要使用在计算机系统中，资源是数量有限且对系统正常运行具有一定作用的
复制链接

扫一扫