C++RAII
RAII,在c++reference(链接)的解释就是资源获取即初始化(Resource Acquisition Is Initialization),是一种C++编程技术。简单来说就是,一个类在构造函数初始化所需要的资源,构造函数释放对应的资源,利用C++局部变量自动释放的机制,可以一定程度上减少内存泄漏。
简单例子
例子一
#include <iostream>
#include <future>
#include <chrono>
class RaiiTest {
public:
RaiiTest(unsigned int size) {
std::cout << "RaiiTest" << std::endl;
size_ = size_;
mem_addr_ = new char[size_]();
}
~RaiiTest() {
std::cout << "~RaiiTest" << std::endl;
if (mem_addr_) delete[] mem_addr_;
}
void WriteTest() {
std::cout << "WriteTest" << std::endl;
for (unsigned int i = 0; i < size_; i++) {
mem_addr_[i] = 100;
}
}
private:
char *mem_addr_ = nullptr;
unsigned int size_ = 0;
};
// 运行结果
// RaiiTest
// WriteTest
// ~RaiiTest
这是最简单的例子,构造函数中new内存,析构函数释放内存。但是代码有个问题,如果在构造函数分配内存失败,会怎样呢?构造函数没有返回值,怎么判断是否内存分配成功呢?查了一些资料之后(关于构造函数的异常处理情况),构造函数出错,向外传递信息只能通过异常了。
请看例子二
例子二
class ChildTest {
public:
ChildTest(int i): i_(i) {std::cout << "ChildTest[" << i_ << "]" << std::endl;}
~ChildTest() {std::cout << "~ChildTest[" << i_ << "]"<< std::endl;}
int i_;
};
class RaiiTest {
public:
RaiiTest(unsigned int size) {
std::cout << "RaiiTest" << std::endl;
size_ = size_;
// mem_addr_ = new char[size_]();
ChildTest child_test(100);
if (mem_addr_) {
std::cout << "mem_addr_ != nullptr" << std::endl;
} else {
std::cout << "mem_addr_ == nullptr" << std::endl;
throw "throw mem_addr_ == nullptr, new failed";
}
}
~RaiiTest() {
std::cout << "~RaiiTest" << std::endl;
if (mem_addr_) delete[] mem_addr_;
}
void WriteTest() {
std::cout << "WriteTest" << std::endl;
for (unsigned int i = 0; i < size_; i++) {
mem_addr_[i] = 100;
}
}
private:
char *mem_addr_ = nullptr;
unsigned int size_ = 0;
};
int main()
{
RaiiTest raii_test(1024);
raii_test.WriteTest();
return 0;
}
// 运行结果
// RaiiTest
// ChildTest[100]
// mem_addr_ == nullptr
// terminate called after throwing an instance of 'char const*'
// Aborted
例子二加上了异常,例子中模拟了内存分配失败的情况,运行结果如上。从结果来看,还存在一个问题,已经实例化的子对象child_test,在异常之后并没有进行析构,如果子对象也申请内存,那么存在内存泄漏的风险。其实我们在主函数加上try catch就可以防止这种情况。
如下例子三
例子三
class ChildTest {
public:
ChildTest(int i): i_(i) {std::cout << "ChildTest[" << i_ << "]" << std::endl;}
~ChildTest() {std::cout << "~ChildTest[" << i_ << "]"<< std::endl;}
int i_;
};
class RaiiTest {
public:
RaiiTest(unsigned int size) {
std::cout << "RaiiTest" << std::endl;
size_ = size_;
// mem_addr_ = new char[size_]();
ChildTest child_test(100);
if (mem_addr_) {
std::cout << "mem_addr_ != nullptr" << std::endl;
} else {
std::cout << "mem_addr_ == nullptr" << std::endl;
throw "throw mem_addr_ == nullptr, new failed";
}
}
~RaiiTest() {
std::cout << "~RaiiTest" << std::endl;
if (mem_addr_) delete[] mem_addr_;
}
void WriteTest() {
std::cout << "WriteTest" << std::endl;
for (unsigned int i = 0; i < size_; i++) {
mem_addr_[i] = 100;
}
}
private:
char *mem_addr_ = nullptr;
unsigned int size_ = 0;
};
int main()
{
try {
RaiiTest raii_test(1024);
raii_test.WriteTest();
} catch(const char *msg) {
std::cout << msg << std::endl;
}
return 0;
}
// 运行结果
// RaiiTest
// ChildTest[100]
// mem_addr_ == nullptr
// ~ChildTest[100]
// throw mem_addr_ == nullptr, new failed
例子三主函数捕获了异常,RaiiTest构造函数实例化的child_test也正常进行了析构。
标准库的包装器
RAII在标准库的典型应用是下面这些。标准库提供几种 RAII 包装器以管理用户提供的资源:
- std::unique_ptr 及 std::shared_ptr 用于管理动态分配的内存,或以用户提供的删除器管理任何以普通指针表示的资源;
- std::lock_guard、std::unique_lock、std::shared_lock 用于管理互斥体。
最常见的就是std::lock_guard的应用了,在多线程加锁解锁的时候很常用
#include <iostream>
#include <future>
#include <chrono>
#include <list>
#include <mutex>
#include <condition_variable>
std::list<int> g_list;
std::mutex g_mtx;
std::condition_variable g_cv;
void Thread0()
{
while (1) {
{
std::unique_lock<std::mutex> lk(g_mtx);
g_list.push_back(10);
// 如果这时候函数逻辑导致程序退出此次循环,那么lk的作用于结束,lk的析构函数会自动调用g_mtx的unlock,防止了没有释放锁的问题而导致
g_cv.notify_all();
std::cout << "g_cv.notify_all" << std::endl;
}
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
void Thread1()
{
while (1) {
{
std::unique_lock<std::mutex> lk(g_mtx);
g_cv.wait(lk, [&](){return !g_list.empty();});
// while (g_list.empty()) {
// g_cv.wait(lk);
// }
std::cout << "Thread1 g_list.size() = " << g_list.size() << std::endl;
int t = g_list.front(); g_list.pop_front();
std::cout << "Thread1 done" << std::endl;
}
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
int main()
{
std::thread th0(Thread0);
std::thread th1(Thread1);
if (th0.joinable()) th0.join();
if (th1.joinable()) th1.join();
return 0;
}