当前位置：首页 > news >正文

惠州网站建设领头羊企业宣传片制作

news 2026/4/7 13:20:42

惠州网站建设领头羊,企业宣传片制作,热门国际新闻,梧州网站推广外包服务RALL是Resource acquisition is initialization的缩写，意思是“资源获取即初始化”，其核心思想是利用C对象生命周期的概念来控制程序的资源。它的技术原理很简单，如果希望对某个重要资源进行跟踪，那么创建一个对象，并将…

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;
}

这时候就不会有问题了。

总结：