cpp_modern/GeneralSnippets/RAII/RAII01.cpp at master · pelocpp/cpp_modern · GitHub

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
// =====================================================================================
// RAII01.cpp
// =====================================================================================

module modern_cpp:raii;

import :dummy;

namespace RAIIDemo {

    template <class TFinalizer>
    class RAII {
    public:
        // c'tor
        explicit RAII(TFinalizer finalizer)
            : m_finalizer{ finalizer }
        {
        }

        // d'tor
        ~RAII() {
            m_finalizer();
        }

        // prevent copy semantics
        RAII(const RAII&) = delete;
        RAII& operator= (const RAII&) = delete;

    private:
        TFinalizer m_finalizer;
    };

    static void test_01()
    {
        {
            Dummy* ptr = new Dummy{ 1 };
            if (ptr == nullptr) {
                return;
            }

            RAII raii{ [&]() { delete ptr; } };
        }

        std::cout << "Done." << std::endl;
    }

    static void test_02()
    {
        // test RAII idiom upon a loop break
        do {
            Dummy* ptr = new Dummy{ 1 };
            if (ptr == nullptr) {
                break;
            }

            RAII raii{ [&]() { delete ptr; } };
            break;
        } while (false);

        std::cout << "Done." << std::endl;
    }

    static void test_03()
    {
        // test RAII idiom upon exception being thrown
        try {
            Dummy* ptr = new Dummy{ 1 };
            if (ptr == nullptr) {
                return;
            }

            RAII raii{ [&]() { delete ptr; } };
            throw 99;
        }
        catch (int n) {
            std::cout << "Exception " << n << " occurred!" << std::endl;
        }

        std::cout << "Done." << std::endl;
    }

    static void test_04()
    {
        // test RAII idiom with two encapsulated resources:
        // Note order of destructor calls

        {
            Dummy* ptr1 = new Dummy{ 1 };
            Dummy* ptr2 = new Dummy{ 2 };

            RAII raii1{ [&]() { delete ptr1; } };
            RAII raii2{ [&]() { delete ptr2; } };
        }

        std::cout << "Done." << std::endl;
    }

    template <class TFinalizer>
    class RAIIContainer
    {
    public:
        RAIIContainer(TFinalizer&& finalizer) : m_raii{ finalizer } {}

    private:
        RAII<TFinalizer> m_raii;
    };

    static void test_05()
    {
        Dummy* ptr = new Dummy{ 1 };
        if (ptr == nullptr) {
            return;
        }

        {
            RAIIContainer cont{ [&]() { delete ptr; } };
        }

        std::cout << "Done." << std::endl;
    }
}

void main_raii()
{
    using namespace RAIIDemo;
    test_01();
    test_02();
    test_03();
    test_04();
    test_05();
}

// =====================================================================================
// End-of-File
// =====================================================================================