C++之RALL机制

news2025/2/24 21:17:15

RALL是Resource acquisition is initialization的缩写，意思是“资源获取即初始化”，其核心思想是利用C++对象生命周期的概念来控制程序的资源。它的技术原理很简单，如果希望对某个重要资源进行跟踪，那么创建一个对象，并将资源的生命周期和对象的生命周期相关联。这样一来C++自带的对象管理设施就可以来管理资源了。

RALL的简单应用

先看一个简单的例子

#include <iostream>  
#include <memory>  

int main()
{
    for (int i = 1; i <= 10000000; i++)
    {
        int* ptr = new int[3];
        ptr[0] = 1;
        ptr[1] = 2;
        ptr[2] = 3;
        //delete ptr;     
    }
    return 0;
}

这里我们打开任务管理器发现

这么小的程序竟然占了500mb内存。原因就是因为没有释放内存，当我们把注释的代码打开后就ok。

所以这里也看到了忘记释放资源的恐怖之处！！！

我们只需要进行一个封装

#include <iostream>  
#include <memory>  
template<typename T>
class auto_ptr
{
public:
    auto_ptr(T* t) :_t(t) {};
    ~auto_ptr()
    {
        delete _t;
    };

    T* getPtr()
    {
        return _t;
    }
private:
    T* _t;
};
;
int main()
{
    for (int i = 1; i <= 10000000; i++)
    {
        auto ptr = auto_ptr<int>(new int[3]);
        int* p = ptr.getPtr();
        p[0] = 1;
        p[1] = 2;
        p[2] = 3;  
    }
    return 0;
}

现在就可以实现自动释放资源了。

这里我们模拟一个简单的智能指针类

原理就是将裸指针进行了一次面向对象的封装，利用栈上的对象在出作用域时自动调用析构函数的特点，保证了资源的释放，解决了内存泄漏问题。

#include<iostream>
using namespace std;
template<class T>
class SmartPtr
{
private:
    T* _ptr;
public:
    SmartPtr(T* ptr = nullptr) :_ptr(ptr) {}
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    T getvalue()
    {
        return *_ptr;
    }
    ~SmartPtr()
    {
        if (_ptr) { delete _ptr; }
    }
};

int main()
{
    SmartPtr<int> ptr(new int(10));
    cout << ptr.getvalue() << endl;
    *ptr.operator->() = 20;
    cout << ptr.getvalue() << endl;
    return 0;
}

之前我们提到互斥锁mutex的特点：一段时间内某个锁资源只能被一个运算单元所占用。所以也就要我们在用完锁后记得解锁，不然会产生死锁现象。

#include<iostream>
#include<thread>
#include<mutex>
void func(string name)
{
    mutex mtx;
    mtx.lock();
    //Mylock<mutex> lock(mtx);
}
int main()
{
    thread t1(func, "窗口A");
    thread t2(func, "窗口B");
    thread t3(func, "窗口C");
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

我们发现程序崩溃，是死锁原因。

忘记释放资源有时候往往不是这位程序员技术高低的问题，而是我们真的不知道资源到底啥时候释放，这时候我们可以对普通的互斥锁进行一次面向对象的封装。

#include<iostream>
using namespace std;
#include<thread>
#include<mutex>
template<class lock>
class Mylock
{
public:
    Mylock(lock& lock)
        :_lock(lock)
    {
        _lock.lock();
    }
    ~Mylock()
    {
        _lock.unlock();
    }
private:
    lock& _lock;
};
void func(string name)
{
    mutex mtx;
    Mylock<mutex> lock(mtx);
}
int main()
{
    thread t1(func, "窗口A");
    thread t2(func, "窗口B");
    thread t3(func, "窗口C");
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

这时候就不会有问题了。

总结：