【c++基础】第五章 RALL机制与智能指针

最新推荐文章于 2024-08-16 23:16:42 发布
最新推荐文章于 2024-08-16 23:16:42 发布
阅读量1.5k 收藏 7
点赞数 4
分类专栏： cpp 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/distant_rove666/article/details/128891216
版权

第五章 RALL机制与智能指针

RAII机制

RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。

当我们 new 出一块内存空间，在使用完之后，如果不使用 delete 来释放这块资源则将导致内存泄露，这在中大型项目中是极具破坏性的。但是人无完人，我们并不能保证每次都记得释放无法再次获取到且不再使用的内存。

为了避免内存申请而由于人为的失误而出现的内存泄漏的问题，C++11把原来Boost库中非常好用的四根智能指针正式转正进入了C++11的标准库中。

C++11给我们程序员提供了四根智能指针，为了帮助程序员们在大中型项目做到资源的自动释放，保证中大型项目的安全，提供了以下四根智能指针：

在这里插入图片描述

智能指针并非是一个指针，而是一个实现指针功能的类对象。

智能指针对象是一个定在栈上的类对象：

他是一个类对象，实现了一个指针功能。意义就是这个栈上类对象托管一块堆上的资源。

智能指针的作用

所以这类对象在构造时，托管一块堆上的资源，在析构时，释放堆上的资源。

所以这个智能指针对象所拥有的特性就是栈上对象出栈时，自动销毁。

auto_ptr资源所有权转移智能指针

简介：

auto_ptr 是通过由 new 表达式获得的对象，并在 auto_ptr 自身被销毁时删除该对象的智能指针。它可用于为动态分配的对象提供异常安全、传递动态分配对象的所有权给函数和从函数返回动态分配的对象。

复制 auto_ptr ，会复制指针并转移所有权给目标： auto_ptr 的复制构造和复制赋值都会修改其右侧参数，而且“副本”不等于原值。因为这些不常见的复制语义，不可将 auto_ptr 置于标准容器中。

封装能够实现指针功能的类对象源码

#include <iostream>
#include <memory>

using namespace std;

class Stu
{
private:
    int _age;
    string _name;
public:
    Stu(int age,string name)
    {
        this->_age=age;
        this->_name=name;
        cout << "Stu structure" << endl;
    }
    void showInfo()
    {
        cout << "姓名：" << this->_name << "，年龄：" << this->_age << endl;
    }
    ~Stu()
    {
        cout << "Stu destruct" << endl;
    }
};

template<class T>
class Auto_ptr
{
private:
    T* _ptr;
public:
    Auto_ptr(T* ptr=nullptr)
    {
        this->_ptr=ptr;
        cout << "Auto_ptr structure" << endl;
    }
    Auto_ptr(Auto_ptr& other)
    {
        this->_ptr=other._ptr;
        other._ptr=nullptr;
        cout << "Auto_ptr copy_structure" << endl;
    }
    Auto_ptr& operator=(Auto_ptr& other)
    {
        cout << "Auto_ptr operator= function" << endl;
        if(this==&other)
        {
            return *this;
        }
        if(nullptr!=other._ptr)
        {
            delete this->_ptr;
            this->_ptr=other._ptr;
            other._ptr=nullptr;
        }
    }
    T* operator->()
    {
        cout << "Auto_ptr operator-> function" << endl;
        return this->_ptr;
    }
    T* get_ptr()
    {
        cout << "Auto_ptr get_ptr_function " << endl;
        return this->_ptr;
    }
    ~Auto_ptr()
    {
        if(nullptr!=this->_ptr)
            delete this->_ptr;
        cout << "Auto_ptr destruct" << endl;
    }
};

int main()
{
    //在堆上开辟对象空间（需要手动释放）
    Stu* stu=new Stu(19,"Tom");
    stu->showInfo();
    delete stu;

    //通过指针模板类，创建对象,用于验证get_ptr()函数
    Auto_ptr<Stu> s1(new Stu(20,"DaMing"));
    //通过get_ptr函数获取属性指针，访问抽象类对象中的成员函数
    s1.get_ptr()->showInfo();
    //指针模板类的拷贝构造，此刻s1所有资源转移
    Auto_ptr<Stu> s2=s1;
    //指针模板类中的->运算符重载函数
    s2->showInfo();
    //通过指针模板类，创建对象
    Auto_ptr<Stu> s3(new Stu(15,"LiLei"));
    s3->showInfo();//指针模板类中的->运算符重载函数
    s3=s2;//指针模板类中的=运算符重载函数，此刻s2所有资源转移
    s3->showInfo();//指针模板类中的->运算符重载函数

    //调用头文件#include<memory>下的
    //auto_ptr智能指针(在c++17弃用)
    auto_ptr<Stu> s4(new Stu(18,"XiaoMei"));
    s4->showInfo();
    return 0;
}

运行结果分析图

在这里插入图片描述

独占智能指针unique_ptr

简介：

unique_ptr智能指针，一个unique_ptr指针只管理一个堆上资源，不发生拷贝构造，也不会等号运算符重载。

unique，英译：独一无二的，唯一的智能指针，他是不共享的，他不像其它的共享对象，也操作他的指向的堆区空间，他是唯一一个可操作这个堆区空间的对象。也就是说他的类对象是不可以发生拷贝构造与赋值运算符重载的。

简单使用方法

#include <iostream>
#include <memory>

using namespace std;

class Stu
{
private:
    int _age;
    string _name;
public:
    Stu(int age,string name)
    {
        this->_age=age;
        this->_name=name;
        cout << "Stu structure" << endl;
    }
    void showInfo()
    {
        cout << "姓名：" << this->_name << "，年龄：" << this->_age << endl;
    }
    ~Stu()
    {
        cout << "Stu destruct" << endl;
    }
};

int main()
{
    unique_ptr<Stu> u1(new Stu(19,"DaMing"));
    u1.get()->showInfo();
    return 0;
}

运行结果分析图

在这里插入图片描述

问题

如何实现内部实现?

  1. 把这个拷贝构造与赋值运算符函数设为私有。
  2. 删除类对象中的成员函数。 //系统给我提供了一个关键字可以把他给删除了。在函数名后面加上 = delete;
unique_ptr(const unique_ptr& ptr) =  delete;
void operator=(unique_ptr& ptr) = delete;

shared_ptr共享智能指针

简介：

shared_ptr共享智能指针是可以由多个栈上的智能指针对象同时托管一块堆资源

shared_ptr内部实现：堆上引用计数器，计数器个数为0时，开始释放内存空间

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

class Stu{
private:
    string name;
    int age;
public:
    Stu(string name,int age){
        this->age=age;
        this->name=name;
    }
    void showInfo(){
        cout << "姓名：" << this->name << ",年龄：" << this->age << endl;
    }
    ~Stu(){
        cout << "stu destruct" << endl;
    }
};

//实现一个Shared_ptr的引用计数
template <class T>
class RefCount{
private:
    T* ptr;
    int count;
public:
    RefCount(T* ptr=nullptr){
        if(ptr!=nullptr){
            this->count=1;
        }else{
            this->count=0;
        }
    }
    //增加引用计数
    void addRef(){
        this->count++;
    }
    //减少引用计数
    int delRef(){
        return --count;
    }
    int get_count(){
        return this->count;
    }
};

template <class T>
class Shared_ptr{
private:
    T* ptr;
    RefCount<T>* refcount;
public:
    //构造函数
    Shared_ptr(T* ptr=nullptr){
        this->ptr=ptr;
        if(this->ptr!=nullptr){
            this->refcount=new RefCount<T>(ptr);
        }else {
            this->refcount=new RefCount<T>();
        }
    }
    //析构函数
    ~Shared_ptr(){
        if(refcount->delRef()==0){
            delete this->ptr;
            this->ptr=nullptr;
            refcount=nullptr;
        }
    }
    //拷贝构造
    Shared_ptr(const Shared_ptr& other){
        if(other.ptr!=nullptr){
            this->ptr=other.ptr;
            this->refcount=other.refcount;
            refcount->addRef();
        }else {
            this->ptr=other.ptr;
            this->refcount=other.refcount;
        }
    }

    //等号运算符重载
    Shared_ptr& operator=(const Shared_ptr& other){
        if(this==&other){
            return this;
        }
        if(other.ptr!=nullptr){
            if(refcount->delRef()==0){
                delete this->ptr;
                delete refcount;
                this->ptr=nullptr;
                refcount=nullptr;
            }
            this->ptr=other.ptr;
            this->refcount=other.refcount;
            refcount->addRef();
        }else{
            if(refcount->delRef()==0){
                delete this->ptr;
                delete refcount;
                this->ptr=nullptr;
                refcount=nullptr;
            }
            this->ptr=other.ptr;
            this->refcount=other.refcount;
        }
    }
    T& operator*(){
        return *ptr;
    }
    T* operator->(){
        return ptr;
    }
    T* get(){
        return ptr;
    }
    int use_count(){
        return refcount->get_count();
    }
};

int main()
{
    Stu *pstu=new Stu("yao",19);
    pstu->showInfo();
    delete pstu;

    shared_ptr<Stu> p(new Stu("liang",20));
    p->showInfo();

    shared_ptr<Stu> p1=p;//是拷贝
    p->showInfo();
    p1->showInfo();

    Shared_ptr<Stu> p2(new Stu("minmin",17));
    p2->showInfo();
    Shared_ptr<Stu> p3=p2;
    p3->showInfo();
    return 0;
}

交叉引用图：

在这里插入图片描述

交叉引用：

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

class B;
class A{
public:
    shared_ptr<B> ptr_b;
    A(){
        cout << "A structure" << endl;
    }
    ~A(){
        cout << "A destruct" << endl;
    }
    //a中的槽函数
    void slot_funtions(){
        cout << "加油！" << endl;
    }
};

class B{
public:
    shared_ptr<A> ptr_a;
    B(){
        cout << "B structure" << endl;
    }
    ~B(){
        cout << "B destruct" << endl;
    }
    void signal(){
        ptr_a->slot_funtions();
    }
};

int main()
{
    shared_ptr<A> p_A(new A());
    shared_ptr<B> p_B(new B());
    p_A->ptr_b=p_B;//等号运算符重载
    p_B->ptr_a=p_A;

    p_B->signal();
    return 0;
}

存在 问题 ：资源泄露，原因引用计数为2，return 时为1，不能析构

解决：std::weak_ptr 的另一用法是打断 std::shared_ptr 所管理的对象组成的环状引用。若这种环被孤立（例如无指向环中的外部共享指针），则 shared_ptr 引用计数无法抵达零，而内存被泄露。能令环中的指针之一为弱指针以避免此情况。

weak_ptr破环指针

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

class B;
class A{
public:
    weak_ptr<B> ptr_b;
    A(){
        cout << "A structure" << endl;
    }
    ~A(){
        cout << "A destruct" << endl;
    }
    //a中的槽函数
    void slot_funtions(){
        cout << "加油！" << endl;
    }
};

class B{
public:
    weak_ptr<A> ptr_a;
    B(){
        cout << "B structure" << endl;
    }
    ~B(){
        cout << "B destruct" << endl;
    }
    void signal(){
        shared_ptr<A> temp=ptr_a.lock();
        if(nullptr!=temp)
            temp->slot_funtions();
    }
};

int main()
{
    shared_ptr<A> p_A(new A());
    shared_ptr<B> p_B(new B());
    p_A->ptr_b=p_B;
    p_B->ptr_a=p_A;

    p_B->signal();
    return 0;
}

强弱智能指针的使用时机：

当智能指针对象直接托管堆上资源时，就是强引用智能指针。

当智能指针对象之间互相引用或赋值时，就使用弱引用智能指针，因为弱引用智能指针，不改变资源的引用记数，不操控堆上资源的属性与方法，他只是一个资源的观察者。这样可以避免堆上资源因交叉引用而出现的资源无法释放的问题。

所以weak_ptr也是shared_ptr的一个黄金搭档。作为强引用智能指针有力补充。

智能指针的问题与解决方案:删除器（Deletor）

#include <iostream>
#include <memory>
#include <functional>
using namespace std;
class A
{
public:
    A()
    {
        cout << "A的构造" << endl;
    }
    ~A()
    {
        cout << "A的析构" << endl;
    }
    void showInfo()
    {
        cout << "hello" << endl;
    }
};
//使用函数对象作为自定删除器：
template <class T>
class Deletor
{
public:
    void operator()(T* p)
    {
        delete []p;
    }
};
template <class T>
void deletor(T* p)//void (*)(T* p)
{
    delete []p;
}
int main()
{
//    1.使用默认删除器，来释放智能指针所托管的堆上连续多个空间的方式。
//    unique_ptr<A,default_delete<A[]>> ptr1(new A[5]);

//    2.使用函数对象作为自定义删除器：
//    unique_ptr<A,Deletor<A>> ptr2(new A[5]);
//    ptr2->showInfo();

//    3.使用函数指针作为自定义删除器：
//    unique_ptr<A,void (*)(A*)> ptr3(new A[5],deletor<A>);
//    ptr3->showInfo();

//    4.使用包装器包装一个函数的调用对象,作为删除器对象。
//    unique_ptr<A,function<void (A*)>> ptr4(new A[5],deletor<A>);
//    ptr4->showInfo();

//    5.使用包装器包装一个lambda表达式，作为自定义删除器。
//    unique_ptr<A,function<void (A*)>> ptr5(new A[5],[](A* p){ delete []p;});
//    ptr5->showInfo();


//    shared_ptr<A> ptr(new A[5],default_delete<A[]>());
//    ptr->showInfo();
//    shared_ptr<A> ptr(new A[5],Deletor<A>());
//    ptr->showInfo();
//    shared_ptr<A> ptr(new A[5],deletor<A>);
//    ptr->showInfo();

    shared_ptr<A> ptr(new A[5],[](A* p){ delete []p;});
    ptr->showInfo();

    return 0;
}
编程远泊
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【具体使用实例】Rall封装线程（C\C++）
肥宅Sean
03-18 1114
局部对象就要被逆序销毁。 通过这个性质，创建一个RAII等待线程完成(RAII，Resource Acquisition Is Initialization)。 这里是通过一个类实现的。通过简单的封装之后，使用起来会比较方便。 这个核心的RALL封装的类代码如下： class ThreadGuard { thread&amp; t; public: explic...
C++：什么是RAII？|智能指针
m0_57719144的博客
06-10 4514
这里的资源主要是指操作系统中有限的东西如内存(heap)、网络套接字，互斥量，文件句柄等等，局部对象是指存储在栈的对象，它的生命周期是由操作系统来管理的，无需人工介入。从该示例可以看出，当我们在fun函数中声明一个局部对象的时候，会自动调用构造函数进行对象的初始化，当整个fun函数执行完成之后，自动调用析构函数来销毁对象，整个过程无需人工介入，由操作系统自动完成，于是自然联想到，当我们在使用资源的时候，在构造函数中进行初始化，在析构函数中进行销毁。智能指针虽然很智能，但容易被误用，智能也是有代价的。
RALL机制和C++11智能指针详解
weixin_39318565的博客
06-21 1612
RALL机制和C++11智能指针详解
C++ Rall机制
weixin_44850236的博客
10-13 209
RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。c.在析构函数中执行销毁操作。d.使用时声明一个该对象的类。a.设计一个类封装资源。b.在构造函数中初始化。
RALL 与 智能指针
BlackMonkeyHH的博客
10-19 1175
什么是RALL思想及其应用，智能指针的理解与实现。
C++ Rall机制详解
热门推荐
越努力越幸运—liupu
04-04 1万+
RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。 那么到底什么是 RALL 机制
C++ RALL机制详解
yyxyong的博客
07-25 1万+
RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。 那么到底什么是 RALL 机制？使用 C+
智能指针(c++)
ClidOvO的博客
05-23 284
RALL是什么 什么是智能指针,裸指针存在的问题 c11 四个智能指针 : 为什么auto_ptr会被弃用 unique_ptr的特点
From Java to C++ 第五篇之智能指针
m0_46622598的博客
05-16 235
前叙 From Java to C++ 第一篇From Java to C++ 第二篇From Java to C++ 第三篇From Java to C++ 第四篇之内存管理篇 回顾 前面我们了解到RALL的基本用法，可以在方法执行完以后，主动将堆内存对象释放掉，从而简化了内存管理，解决内存泄漏的可能，这次我们学习下RALL，如果做一个完善的智能指针。 智能指针的本质 它的出现其实是为了解决由于...
C++(9)：智能指针
kimEHEH的博客
11-28 222
一、智能指针 1.RALL：使用局部对象来管理资源的技术成为资源获取即初始化。 如何让资源自动销毁，即利用RALL，利用局部对象自动销毁的特性来控制资源生命周期。 2.注意智能指针中.和->的区别 3.智能指针的拷贝构造 4.智能指针的拷贝函数 5.unique_ptr 是一个独享所有权的智能指针，无拷贝构造和赋值函数。创建：unique_ptr<Test>(newTest(10)) share_ptr资源可以被多个指针共享。...
【BOOST C++ 1指针专题 】 01 RAII和内存管理
gongdiwudu的专栏
09-25 3530
RAII 代表资源获取即初始化。这个词语背后的想法：对于任何获取的资源，都应该初始化一个对象，该对象将拥有该资源并在析构函数中关闭它。
C++面试基础知识汇总
weixin_44190603的博客
08-21 934
C++面试基础知识汇总 本篇文章用于C++面试基础知识复习，不断更新。自用。 1.new/delete/malloc/free关系 new/delete属于C++语言中的运算符，malloc/free属于C语言中的标准库函数； 它们都可用于申请动态内存和释放内存； 对于非内部数据类型的对象而言，malloc/free无法满足动态对象的要求，对象消亡时，delete可以执行对象的析构函数，malloc只会释放内存。 2.delete与delete[]的区别 delete只会调用一次析构函数，而delete[]
C++中的资源管理技术---RALL
cheny的博客
12-25 516
RAII的核心思想是：在对象的构造函数中获取资源，在对象的析构函数中释放资源，从而确保资源在对象的生命周期内始终可用，并且在对象不再需要时能够正确释放。通过使用RAII，我们可以更方便地管理资源，提高代码的可读性和可维护性，并避免资源泄漏和异常导致的问题。简化资源管理：通过将资源的获取和释放操作封装到对象的构造函数和析构函数中，可以避免手动管理资源的复杂性。异常安全性：由于资源的获取和释放操作都在对象的构造函数和析构函数中完成，即使在发生异常时，也能保证资源的正确释放。在上述示例中，我们定义了一个。
C++必知必会RALL与Pimpl
滴答滴答的迪迦的博客
09-24 1054
RALL Pimpl惯用法
C++的RALL机制
最新发布
yao_tao11的博客
08-16 339
RAII 是 C++ 中处理资源管理的强大方法，特别适合需要频繁分配和释放资源的场景。通过将资源与对象生命周期绑定，RAII 使代码更具可读性、异常安全性，并有效防止资源泄漏。这一模式在现代 C++ 编程中广泛应用，尤其是在管理内存、文件、线程同步等场景中。
RALL和智能指针
卖火柴的小男孩
09-10 1113
RAII机制RAII的本质内容是用对象代表资源，把管理资源的任务转化为管理对象的任务，将资源的获取和释放与对象的构造和析构对应起来，从而确保在对象的生存期内资源始终有效，对象销毁时资源一定会被释放。说白了，就是拥有了对象，就拥有了资源，对象在，资源则在。所以，RAII机制是进行资源管理的有力武器，C++程序员依靠RAII写出的代码不仅简洁优雅，而且做到了异常安全。特点在栈语义和操作符重载的支持下，C
RALL
yx20130919的博客
06-28 1377
产生原因： 在C++中，如果在这个程序段结束时需要完成一些资源释放工作，那么正常情况下自然是没有什么问题，但是当一个异常抛出时，释放资源的语句就不会被执行。于是Bjarne Stroustrup就想到确保能运行资源释放代码的地方就是在这个程序段（栈帧）中放置的对象的析构函数了，因为stack winding会保证它们的析构函数都会被执行。 将初始化和资源释放都移动到一个包装类中的...
c++多线程之利用RALL技术写一个安全的临界区
FairLikeSnow的博客
06-18 453
CRITICAL_SECTION g_cs; class CMySafeLock { public: CMySafeLock(CRITICAL_SECTION *p) { m_pCS = p; cout << "----------------lock------------------\n"; EnterCriticalSection(m_pCS); } ~CMySafeLock() { LeaveCriticalSection(m_pCS); cout &lt
c++ RAII
YRC333的博客
04-17 517
概念：RALL(Resource Acquisition Is Initialization),也称为“资源获取就是初始化”，是c++语言的一种管理资源，避免泄漏的惯用法。 效果：c++标准保证任何情况下，已构造的对象（生命周期结束时）最终会销毁，即它的析构函数最终会被调用。 智能指针就是通过使用RAII技术，来保证资源正确的初始化和释放，实质上是一个对象，行为上表现得却像一个指针 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程远泊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值