日常随笔(c++11)——RAII与智能指针

最新推荐文章于 2024-03-23 18:17:28 发布
最新推荐文章于 2024-03-23 18:17:28 发布
阅读量885 收藏 3
点赞数 1
分类专栏： 日常随笔 C++ 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44700810/article/details/121154287
版权

文章目录

1. RAII机制

RAII全程是Resource Acquisition Is Initialization（资源获取初始化），是C++的一种管理资源、避免内存泄漏的方法。利用的就是C++构造的对象最终都会被销毁的原则。
RAII的做法就是使用一个对象，在对象被构造是申请获取其对应的资源；在对象生命周期内控制对资源的访问，使之保持有效；在对象析构的时候，释放构造时获取的资源

1.1 为什么要使用RAII

  1. 计算机资源是有限的，不能够一直申请新的资源，而不释放已用完的资源。在使用资源的时候，必须遵循一个步骤：
    1. 申请资源
    2. 使用资源
    3. 释放资源
      第一步和第二步缺一不可，如果资源使用完成后，不进行释放，则会造成内存泄漏。
  2. 提高程序的效率和可理解性、可维护性
    下面的一个例子，就是申请资源、使用资源、释放资源的过程：
#include <iostream> 

using namespace std; 

int main() 

{ 
    int *testArray = new int [10]; 
    // Here, you can use the array 
    delete [] testArray; 
    testArray = NULL ; 
    return 0; 
}

这是一个简单的例子，如果在大型程序中，都这样设计，代码就会显得很臃肿，而且开发的时候也很容易遗忘释放申请过的资源。

1.2 如何使用RAII

当我们在一个函数内部使用局部变量，当退出了这个局部变量的作用域时，这个变量也就别销毁了；当这个变量是类对象时，这个时候，就会自动调用这个类的析构函数，而这一切都是自动发生的，不要程序员显示的去调用完成。这个也太好了，RAII就是这样去完成的

由于系统的资源不具有自动释放的功能，而C++中的类具有自动调用析构函数的功能。如果把资源用类进行封装起来，对资源操作都封装在类的内部，在析构函数中进行释放资源。当定义的局部变量的生命结束时，它的析构函数就会自动的被调用，如此，就不用程序员显示的去调用释放资源的操作了。

下面给出一个将互斥锁封装的例子：

#include "mutex.h"

class  MutexLock {
 public:
  explicit MutexLock(Mutex *mu)
      : mu_(mu)  {
    this->mu_->Lock();
  }
  ~MutexLock() { this->mu_->Unlock(); }

 private:
  Mutex *const mu_;
  // No copying allowed
  MutexLock(const MutexLock&);
  void operator=(const MutexLock&);
};

当创建MutexLock对象的时候，将会将锁锁上，当MutexLock对象析构的时候，就会将锁解开，使用如下：

#include "mutexlock.hpp"
#include <unistd.h>
#include <iostream>

#define    NUM_THREADS     10000

int num=0;
Mutex mutex;

void *count(void *args) {
    MutexLock lock(&mutex);
    num++;
}


int main() {
    int t;
    pthread_t thread[NUM_THREADS];

    for( t = 0; t < NUM_THREADS; t++) {   
        int ret = pthread_create(&thread[t], NULL, count, NULL);
        if(ret) {   
            return -1;
        }   
    }

    for( t = 0; t < NUM_THREADS; t++)
        pthread_join(thread[t], NULL);
    std::cout << num << std::endl;
    return 0;
}

2. 智能指针

智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、weak_ptr
C++11中引入智能指针的概念，是为了方便管理堆内存。使用普通指针，容易造成内存泄漏（忘记释放），二次释放等问题。

堆是用来存放运行过程中动态分配的内存段，大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）

理解智能指针还应该从以下三个层次考虑：

  1. 从较浅的层面看，智能指针是利用了一种叫做RAII（资源获取即初始化）的技术对普通的指针进行封装，这使得智能指针实质是一个对象，即在创建和析构的时候会自动对申请的资源进行管理，行为表现的却像一个指针。

  2. 智能指针的作用是防止忘记调用delete释放内存和程序异常的进入catch块忘记释放内存。另外指针的释放时机也是非常有考究的，多次释放同一个指针会造成程序崩溃，这些都可以通过智能指针来解决。

  3. 智能指针还有一个作用是把值语义转换成引用语义。C++和Java有一处最大的区别在于语义不同，在Java里面下列代码：
    Animal a = new Animal();
    Animal b = a;
    这里其实只生成了一个对象，a和b仅仅是把持对象的引用而已。但在C++中不是这样，
    Animal a;
    Animal b = a;

    这里却是就是生成了两个对象。

2.1 智能指针的使用

2.1.1 share_ptr的使用

share_ptr可以实现多个指针指向相同的对象。shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，自动删除所指向的堆内存。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要加锁。

  • 初始化。智能指针是个模板类，可以指定类型，传入指针通过构造函数初始化。也可以使用make_shared函数初始化。不能将指针直接赋值给一个智能指针，一个是类，一个是指针。例如std::shared_ptr p4 = new int(1);的写法是错误的
  • 拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象。
  • get函数获取原始指针
  • 注意不要用一个原始指针初始化多个shared_ptr，否则会造成二次释放同一内存
  • 注意避免循环引用，shared_ptr的一个最大的陷阱是循环引用，循环，循环引用会导致堆内存无法正确释放，导致内存泄漏。循环引用在weak_ptr中介绍。
#include <iostream>
#include <memory>

int main() {
    {
        int a = 10;
        std::shared_ptr<int> ptra = std::make_shared<int>(a);
        std::shared_ptr<int> ptra2(ptra); //copy
        std::cout << ptra.use_count() << std::endl;

        int b = 20;
        int *pb = &a;
        //std::shared_ptr<int> ptrb = pb;  //error 不能用指针赋值
        std::shared_ptr<int> ptrb = std::make_shared<int>(b);

        ptra2 = ptrb; //assign
        pb = ptrb.get(); //获取原始指针

        std::cout << ptra.use_count() << std::endl;
        std::cout << ptrb.use_count() << std::endl;
        std::cout << "ptra : " << *ptra << std::endl;
        std::cout << "ptrb : " << *ptrb << std::endl;
    }
}
2.1.2 unique_ptr的使用

unique_ptr“唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。相比与原始指针unique_ptr用于其RAII的特性，使得在出现异常的情况下，动态资源能得到释放。unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权

#include <iostream>
#include <memory>

int main() {
    {
        std::unique_ptr<int> uptr(new int(10));  //绑定动态对象
        //std::unique_ptr<int> uptr2 = uptr;  //不能賦值
        //std::unique_ptr<int> uptr2(uptr);  //不能拷貝
        std::unique_ptr<int> uptr2 = std::move(uptr); //轉換所有權
        uptr2.release(); //释放所有权
    }
    //超過uptr的作用域，內存釋放
}
2.1.3 weak_ptr的使用

weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->,它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。

  • weak_ptr可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。
  • 使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0,但更快，表示被观测的资源(也就是shared_ptr的管理的资源)已经不复存在。
  • weak_ptr可以使用一个非常重要的成员函数lock()从被观测的shared_ptr获得一个可用的shared_ptr对象， 从而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr。
#include <iostream>
#include <memory>

int main() {
    {
        std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
        std::cout << sh_ptr.use_count() << std::endl;

        std::weak_ptr<int> wp(sh_ptr);
        std::cout << wp.use_count() << std::endl;

        if(!wp.expired()){
            std::shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
            *sh_ptr = 100;
            std::cout << wp.use_count() << std::endl; // if语句结束后，将会释放sh_ptr2，wp.use_count将会等于1
        }
    }
    //delete memory
}

2.2 普通指针的局限性

考虑一个简单的对象建模——家长与子女：a Parent has a Child, a Child knowshis/her Parent。
如果使用原始指针作为成员，Child和Parent由谁释放？那么如何保证指针的有效性？如何防止出现空悬指针？这些问题是C++面向对象编程麻烦的问题，下面的原始指针做法，就会造成空悬指针的问题，即指针会指向一块已经释放的地址。

#include <iostream>
#include <memory>

class Child;
class Parent;

class Parent {
private:
    Child* myChild;
public:
    void setChild(Child* ch) {
        this->myChild = ch;
    }

    void doSomething() {
        if (this->myChild) {

        }
    }

    ~Parent() {
        delete myChild;
    }
};

class Child {
private:
    Parent* myParent;
public:
    void setPartent(Parent* p) {
        this->myParent = p;
    }
    void doSomething() {
        if (this->myParent) {

        }
    }
    ~Child() {
        delete myParent;
    }
};

int main() {
    {
        Parent* p = new Parent;
        Child* c =  new Child;
        p->setChild(c);
        c->setPartent(p);
        delete c;  //only delete one，此时p的指针会指向一片已释放的区域
    }
    return 0;
}

2.3 循环引用

shared_ptr轻松解决生命周期的问题，不必担心空悬指针。但是这个模型存在循环引用的问题，即当有两个类，内部成员都包含一个指向另一个类对象的指针，此时如果使用share_ptr，就会造成循环引用。

#include <iostream>
#include <memory>

struct A;
struct B;

struct A {
    int n = 1;
    std::shared_ptr<B> pointer;
    ~A() {
        std::cout << "A 被销毁" << std::endl;
    }
};
struct B {
    int m = 1;
    std::shared_ptr<A> pointer;
    ~B() {
        std::cout << "B 被销毁" << std::endl;
    }
};

int main() {
    std::weak_ptr<A> ptr_A;
    std::weak_ptr<B> ptr_B;
    {
        auto a = std::make_shared<A>();
        auto b = std::make_shared<B>();
        ptr_A = a;
        ptr_B = b;
        a->pointer = b;
        b->pointer = a;
        std::cout << a.use_count() << std::endl;    // 2,此处的2是因为函数内部的pointer引起，并不是因为weak_ptr
        std::cout << b.use_count() << std::endl;    // 2
    }
    std::cout << ptr_A.use_count() << std::endl;    // 1，由于出现了循环引用，在进行释放的时候，无法使两者完全释放
    std::cout << ptr_B.use_count() << std::endl;    // 1
}

用家长与子女类：

#include <iostream>
#include <memory>

class Child;
class Parent;

class Parent {
private:
    std::shared_ptr<Child> ChildPtr;
public:
    void setChild(std::shared_ptr<Child> child) {
        this->ChildPtr = child;
    }

    void doSomething() {
        if (this->ChildPtr.use_count()) {

        }
    }

    ~Parent() {
    }
};

class Child {
private:
    std::shared_ptr<Parent> ParentPtr;
public:
    void setPartent(std::shared_ptr<Parent> parent) {
        this->ParentPtr = parent;
    }
    void doSomething() {
        if (this->ParentPtr.use_count()) {

        }
    }
    ~Child() {
    }
};

int main() {
    std::weak_ptr<Parent> wpp;
    std::weak_ptr<Child> wpc;
    {
        std::shared_ptr<Parent> p(new Parent);
        std::shared_ptr<Child> c(new Child);
        p->setChild(c);
        c->setPartent(p);
        wpp = p;
        wpc = c;
        std::cout << p.use_count() << std::endl; // 2，此处的2是由于成员函数造成，并不是因为weak_ptr
        std::cout << c.use_count() << std::endl; // 2
    }
    std::cout << wpp.use_count() << std::endl;  // 1
    std::cout << wpc.use_count() << std::endl;  // 1
    return 0;
}

2.4 正确的解决方法

用weak_ptr代替其中的一个share_ptr。

#include <iostream>
#include <memory>

class Child;
class Parent;

class Parent {
private:
    //std::shared_ptr<Child> ChildPtr;
    std::weak_ptr<Child> ChildPtr;
public:
    void setChild(std::shared_ptr<Child> child) {
        this->ChildPtr = child;
    }

    void doSomething() {
        //new shared_ptr
        if (this->ChildPtr.lock()) {

        }
    }

    ~Parent() {
    }
};

class Child {
private:
    std::shared_ptr<Parent> ParentPtr;
public:
    void setPartent(std::shared_ptr<Parent> parent) {
        this->ParentPtr = parent;
    }
    void doSomething() {
        if (this->ParentPtr.use_count()) {

        }
    }
    ~Child() {
    }
};

int main() {
    std::weak_ptr<Parent> wpp;
    std::weak_ptr<Child> wpc;
    {
        std::shared_ptr<Parent> p(new Parent);
        std::shared_ptr<Child> c(new Child);
        p->setChild(c);
        c->setPartent(p);
        wpp = p;
        wpc = c;
        std::cout << p.use_count() << std::endl; // 2
        std::cout << c.use_count() << std::endl; // 1
    }
    std::cout << wpp.use_count() << std::endl;  // 0
    std::cout << wpc.use_count() << std::endl;  // 0
    return 0;
}

3 参考链接

C++中的RAII机制
C++中的智能指针的原理、使用、实现

Overcautious
关注
专栏目录
【C++干货铺】 RAII实现智能指针
qq_55119554的博客
01-24 1581
本篇文章介绍了根据RAII实现的三种智能指针！！！
C++ 11 学习总结——智能指针
萧海的博客
08-03 390
智能指针 什么是智能指针？ 智能指针是借用RAII技术对普通指针进行封装，实质是一个对象，表现为一个指针，即智能的管理动态资源的释放；（重载操作符（->和*））； 对于编译器来说，智能指针实际上是一个栈对象，并非指针类型，在栈对象生命期即将结束时，智能指针通过析构函数释放有它管理的堆内存。 什么是RAII技术？ RAII技术即资源分配及初始化，使用类来封装资源的分配和初始化，再构造函数完成资源的分配和初始化，析构函数完成资源的清理，可以保证正确的初始化和资源释放。 智能指针的作用 del
RAII和智能指针的实现
xy913741894的博客
04-05 2167
RAII在C++effective一书中讲到，RAII是“Resource acquisition is initialization”，直译为“资源获取就是初始化”。它是基于这样的原理，栈的变量会自动销毁，（自定义类型对象会调用析构函数）。它是将管理资源变为管理对象，将资源封装成类，利用构造函数来获取并初始化资源，析构函数来释放资源，从而保证资源的正确获取，初始化以及释放。从而避免了因此异常等其他
浅谈RAII&智能指针
weixin_33922672的博客
04-15 354
关于RAII，官方给出的解释是这样的“资源获取就是初始化”。听起来貌似不是很懂的哈，其实说的通俗点的话就是它是一种管理资源，避免内存泄漏的一种方法。它可以保证在各种情况下，当你对对象进行使用时先通过构造函数来进行资源的分配和初始化，最后通过析构函数来进行清理，有效的保证了资源的正确分配和释放。（特别是在异常中，因为异常往往会改变代码正确的执行顺序，这就很容易引起资源管理的...
C++的RAII和智能指针小结
weixin_34128501的博客
04-06 243
RAII:资源分配即初始化，利用构造函数和析构函数定义一个类来完成对资源的分配和释放智能指针主要用来防止内存泄漏，我们来举个栗子，看看为什么会有智能指针这个东东例1：对于上面这段程序，由于抛出异常的时候影响了代码的执行流，所以要在异常捕获之前将p提前释放（详见我的博客：C++的异常浅析），虽然可以通过再次抛出以异常解决这个问题，但是在代码美观方面不够完美，更重要的是如果在代码...
C++智能指针（转载）
岁月留痕
01-12 928
今天才知道这种内存管理机制有个专属名词——“智能指针”，out了……转载： C++技巧(标准auto_ptr智能指针机制　　很多人听说过标准auto_ptr智能指针机制，但并不是每个人都天天使用它。这真是个遗憾，因为auto_ptr优雅地解决了C++设计和编码中常见的问题，正确地使用它可以生成健壮的代码。本文阐述了如何正确运用auto_ptr来让你的
c++智能指针（raii）
xiao_xiao21的博客
11-24 1131
c++智能指针（raii）
2. RAII与智能指针1
08-03
使用智能指针和RAII技术，可以显著减少C++程序中内存泄漏和资源管理的问题，提高代码的健壮性和可靠性。特别是在大型项目中，智能指针和RAII使得资源管理更加自动化，降低了内存泄漏的排查难度。开发人员可以更专注...
【C++11】三大神器之——智能指针
ZER00000001的博客
12-13 3354
在Cpp11新标准下学习C++三大神器之一的智能指针
C++ 中的 RAII（资源获取即初始化）是什么
最新发布
09-14
在C++中，RAII（Resource Acquisition Is Initialization，资源获取即初始化）是一种管理资源的编程技术，它通过将资源的生命周期绑定到对象的生命周期来确保资源的正确获取和释放。这种技术利用了C++的构造函数和...
C++RAII机制与智能指针
GUI1259802368的博客
12-17 1639
一个简单的例子是一个RAII机制文件类。不用RAII的代码如下： File file("/path/to/file"); // Do stuff with file file.close(); 换句话说，我们必须确保在完成文件后关闭文件。 这有两个缺点 - 首先，无论我们在哪里使用File，都必须调用File :: close（） - 如果我们忘记这么做的话，我们会比我们...
【C++】智能指针 RAII
ly_6699的博客
04-07 392
1. 智能指针的使用和原理： RAII+重载操作符 * 和 -> 2. 三种智能指针的介绍 auto_ptr：原理- 管理权转移，不足- 拷贝后前指针悬空会导致出现野指针，禁止使用 unique_ptr：原理- 禁止任何拷贝，不足- 无法完成拷贝，可鼓励使用 shared_ptr：原理- 通过引用计数实现资源共享，不足- 会出现线程安全和循环引用的问题，不过循环引用问题的解决可用weak_ptr
C/C++：RAII和智能指针
ShellDawn的博客
07-06 330
RAII是解决程序员忘记释放资源的问题 RAII是一种思想，可以通过类实现，在生命周期构造和析构，成对儿出现，不会内存泄漏。 RAII最有名应该是智能指针： unique_ptr{\red{unique\_ptr}}unique_ptr：指针对象一一对应，若想改变指针指向的内容，只能使用std::move方法，其原理也是析构原unique_str指针和资源，新建指针赋予新资源，返回指针。 shar...
RAII 与智能指针
许挂挂的博客
03-23 944
1.概念Resource Acquisition Is Initialization 资源获取即初始化。一般分为 3 步，当我们在main函数中声明一个局部对象的时候，会自动调用构造函数进行对象的初始化，当整个main函数执行完成后，自动调用析构函数来销毁对象，整个过程无需人工介入，由操作系统自动完成；2.如何使用 raii。
RAII与智能指针
weixin_43308899的博客
01-17 965
本文主要介绍C++中的RAII理念以及智能指针的使用，并举出了相应的例子进行举例说明。
RAII技术与智能指针（超详细）
qq_40728775的博客
08-22 1616
RAII技术与智能指针 RAII技术 什么是RAII技术 RAII，即Resource Acquisition Is Initialization，“资源获取就是初始化”，是C++语言的一种管理资源、避免泄漏的一种方法。 是一种资源管理技术，利用对象的生命周期管理程序的资源（如内存，文件句柄，锁等）的技术，因为对象在离开作用域的时候，会自动调用析构函数。 实现原理 利用对象的生命周期管理资源，在对象离开作用域时，会自动调用析构函数。 特征 在构造时初始化资源，或叫做托管资源。 在析构时释放资源 不允许赋值
智能指针及RAII
森森猪的博客
03-06 204
智能指针及RAII 问题 C++中最令人头疼的问题是强迫程序员对申请的资源（文件，内存等）进行管理，一不小心就会出现泄露（忘记对申请的资源进行释放）的问题。 // C++ auto ptr = new std::vector<int>(); //使用了垃圾回收技术,不在需要人为管理，相关的虚拟机会自动释放不需要使用的资源。 // Java ArrayList<int> list = new ArrayList<int>(); # Python lst = list(
RAII--智能指针
假正经Leo先生
01-25 510
为什么需要RAII（Resource Acquisition Is Initialization）？ 当动态申请了空间之后，在不需要这个空间的时候一定要释放，否则存在内存泄漏问题？那么我们怎么保证，自己申请的空间都被释放了呢？如果程序抛异常了，还可以保证吗？ 什么是RAII？管理资源、避免内存泄露 构造函数时候把资源保存起来，以便使用完毕后释放。 return（return前释放）、抛异常（二次抛...
详解C++11 RAII机制
长期更新自学笔记
06-08 4466
什么是RAII？RAII是Resource Acquisition Is Initialization（wiki上面翻译成 “资源获取就是初始化”）的简称，是C++语言的一种管理资源、避免泄漏的惯用法。利用的就是C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象，在其构造时获取对应的资源，在对象生命期内控制对资源的访问，使之始终保持有效，最后在对象析构的时候，释放构造时获取的资源。为什么要使用RAII？上面说到RAII是用来管理资源、避免资源泄漏的方法。那么，用了这么久了，也写了这么多程序了，
C++智能指针与循环引用：深入解析与实践
为了解决这些问题，C++引入了智能指针，这是一种特殊类型的指针，利用RAII（Resource Acquisition Is Initialization，即资源获取即初始化）原则来管理动态资源，如内存或系统资源。 智能指针在C++标准库的头文件中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值