C++RAII

发表于 更新于 分类于

RAII，在c++reference（链接）的解释就是资源获取即初始化（Resource Acquisition Is Initialization），是一种C++编程技术。简单来说就是，一个类在构造函数初始化所需要的资源，构造函数释放对应的资源，利用C++局部变量自动释放的机制，可以一定程度上减少内存泄漏。

简单例子

例子一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#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内存，析构函数释放内存。但是代码有个问题，如果在构造函数分配内存失败，会怎样呢？构造函数没有返回值，怎么判断是否内存分配成功呢？查了一些资料之后(关于构造函数的异常处理情况)，构造函数出错，向外传递信息只能通过异常了。
请看例子二

例子二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
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就可以防止这种情况。
如下例子三

例子三

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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的应用了，在多线程加锁解锁的时候很常用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#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;
}