RAII: Resource Acquisition Is Initialization

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

// Traditional C-style manual resource management
FILE* file = fopen("data.txt", "r");
if (file == NULL) {
    return ERROR_OPEN_FAILED;
}
 
char* buffer = malloc(1024);
if (buffer == NULL) {
    fclose(file);  // Must remember to close file!
    return ERROR_ALLOC_FAILED;
}
 
// Process the file...
int result = process_data(file, buffer);
 
if (result != SUCCESS) {
    free(buffer);   // Must remember to free buffer!
    fclose(file);   // Must remember to close file!
    return result;
}
 
// What if we add a new error path here?
// What if we forget to add cleanup?
// What if an exception is thrown? (in C++)
 
free(buffer);
fclose(file);
return SUCCESS;

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

// RAII File Wrapper in C++
class FileHandle {
private:
    FILE* file_;
    
public:
    // Constructor acquires the resource
    explicit FileHandle(const char* path, const char* mode) 
        : file_(fopen(path, mode)) 
    {
        if (!file_) {
            throw std::runtime_error("Failed to open file");
        }
    }
    
    // Destructor releases the resource - ALWAYS called
    ~FileHandle() {
        if (file_) {
            fclose(file_);
            // Guaranteed cleanup, no matter how we exit scope
        }
    }
    
    // Prevent copying (who owns the resource?)
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // Enable move semantics (transfer ownership)
    FileHandle(FileHandle&& other) noexcept 
        : file_(other.file_) 
    {
        other.file_ = nullptr;  // Source no longer owns resource
    }
    
    // Provide access to the wrapped resource
    FILE* get() const { return file_; }
    
    size_t read(void* buffer, size_t size, size_t count) {
        return fread(buffer, size, count, file_);
    }
};
 
// Usage - notice the simplicity
void processFile(const char* path) {
    FileHandle file(path, "r");  // Resource acquired here
    
    char buffer[1024];
    file.read(buffer, 1, sizeof(buffer));
    
    // Even if doWork() throws an exception...
    doWork(buffer);
    
    // ...file is automatically closed when we leave scope
}  // <- Destructor called here, file closed

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

// RAII enables strong exception safety
class Transaction {
private:
    Database& db_;
    bool committed_ = false;
    
public:
    explicit Transaction(Database& db) : db_(db) {
        db_.beginTransaction();
    }
    
    ~Transaction() {
        if (!committed_) {
            db_.rollback();  // Automatic rollback if not committed
        }
    }
    
    void commit() {
        db_.commit();
        committed_ = true;
    }
    
    // Non-copyable, movable
    Transaction(const Transaction&) = delete;
    Transaction& operator=(const Transaction&) = delete;
};
 
// Usage demonstrates exception safety
void transferMoney(Account& from, Account& to, Money amount) {
    Transaction txn(database);  // Transaction starts
    
    from.debit(amount);   // Throws if insufficient funds
    to.credit(amount);    // Throws if account locked
    
    // Other validation...
    validateTransfer(from, to, amount);  // Might throw
    
    txn.commit();  // Only reached if everything succeeds
}
// If ANY exception is thrown, txn destructor runs,
// rolling back the transaction - GUARANTEED
 
// Compare to manual approach:
void transferMoneyManual(Account& from, Account& to, Money amount) {
    database.beginTransaction();
    try {
        from.debit(amount);
        try {
            to.credit(amount);
            try {
                validateTransfer(from, to, amount);
                database.commit();
            } catch (...) {
                database.rollback();
                throw;
            }
        } catch (...) {
            database.rollback();
            throw;
        }
    } catch (...) {
        database.rollback();
        throw;
    }
}
// Deeply nested, error-prone, unmaintainable

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

#include <mutex>
#include <shared_mutex>
 
class BankAccount {
private:
    mutable std::mutex mutex_;
    double balance_ = 0.0;
    
public:
    double getBalance() const {
        // lock_guard acquires lock in constructor
        std::lock_guard<std::mutex> lock(mutex_);
        return balance_;
    }  // lock automatically released here
    
    void deposit(double amount) {
        std::lock_guard<std::mutex> lock(mutex_);
        
        // Even if validate() throws, the lock is released
        validate(amount);
        
        balance_ += amount;
    }  // lock released - guaranteed
    
    void withdraw(double amount) {
        std::unique_lock<std::mutex> lock(mutex_);
        
        if (balance_ < amount) {
            // unique_lock can be manually managed if needed
            lock.unlock();
            notifyInsufficientFunds();
            return;
        }
        
        balance_ -= amount;
    }  // if still locked, released here
};
 
// Reader-writer lock with shared_mutex
class Cache {
private:
    mutable std::shared_mutex mutex_;
    std::unordered_map<Key, Value> data_;
    
public:
    Value get(const Key& key) const {
        // Multiple readers can hold shared lock simultaneously
        std::shared_lock<std::shared_mutex> lock(mutex_);
        auto it = data_.find(key);
        return it != data_.end() ? it->second : Value{};
    }
    
    void put(const Key& key, Value value) {
        // Writers get exclusive access
        std::unique_lock<std::shared_mutex> lock(mutex_);
        data_[key] = std::move(value);
    }
};

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

// Java's try-with-resources (since Java 7)
// Implements RAII semantics for AutoCloseable resources
 
// Any class implementing AutoCloseable can be used
public class DatabaseConnection implements AutoCloseable {
    private Connection connection;
    
    public DatabaseConnection(String url) throws SQLException {
        // Resource acquired in constructor
        this.connection = DriverManager.getConnection(url);
    }
    
    @Override
    public void close() throws SQLException {
        // Resource released when close() is called
        if (connection != null) {
            connection.close();
        }
    }
    
    public ResultSet query(String sql) throws SQLException {
        return connection.createStatement().executeQuery(sql);
    }
}
 
// Usage - RAII-style automatic cleanup
public void processData() throws SQLException {
    // Multiple resources can be managed together
    try (DatabaseConnection db = new DatabaseConnection(url);
         BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
        
        String line = reader.readLine();
        db.query("INSERT INTO logs VALUES ('" + line + "')");
        
        // Even if an exception is thrown here...
        processMore();
        
    }  // Both db and reader are automatically closed
    // close() is called in reverse order of declaration
}
 
// What happens under the hood:
public void processDataExpanded() throws SQLException {
    DatabaseConnection db = new DatabaseConnection(url);
    Throwable primary = null;
    try {
        BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
        try {
            // ... use resources ...
        } finally {
            try {
                reader.close();
            } catch (Throwable t) {
                if (primary != null) {
                    primary.addSuppressed(t);  // Handle multiple exceptions!
                } else {
                    primary = t;
                }
            }
        }
    } finally {
        // ... close db similarly ...
    }
    if (primary != null) throw primary;
}

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

// Well-designed RAII wrapper template
template<typename Resource, typename Releaser>
class UniqueResource {
private:
    Resource resource_;
    Releaser releaser_;
    bool engaged_ = false;
    
public:
    // Construct from resource and releaser
    UniqueResource(Resource&& resource, Releaser&& releaser)
        : resource_(std::move(resource))
        , releaser_(std::move(releaser))
        , engaged_(true) 
    {}
    
    // Destructor releases if engaged
    ~UniqueResource() {
        if (engaged_) {
            releaser_(resource_);
        }
    }
    
    // Delete copy
    UniqueResource(const UniqueResource&) = delete;
    UniqueResource& operator=(const UniqueResource&) = delete;
    
    // Enable move
    UniqueResource(UniqueResource&& other) noexcept
        : resource_(std::move(other.resource_))
        , releaser_(std::move(other.releaser_))
        , engaged_(other.engaged_)
    {
        other.engaged_ = false;  // Transfer ownership
    }
    
    UniqueResource& operator=(UniqueResource&& other) noexcept {
        if (this != &other) {
            if (engaged_) {
                releaser_(resource_);
            }
            resource_ = std::move(other.resource_);
            releaser_ = std::move(other.releaser_);
            engaged_ = other.engaged_;
            other.engaged_ = false;
        }
        return *this;
    }
    
    // Access underlying resource
    Resource& get() noexcept { return resource_; }
    const Resource& get() const noexcept { return resource_; }
    
    // Pointer-like access
    Resource* operator->() noexcept { return &resource_; }
    const Resource* operator->() const noexcept { return &resource_; }
    
    // Release ownership (caller becomes responsible)
    Resource release() noexcept {
        engaged_ = false;
        return std::move(resource_);
    }
    
    // Reset with new resource
    void reset(Resource&& newResource) {
        if (engaged_) {
            releaser_(resource_);
        }
        resource_ = std::move(newResource);
        engaged_ = true;
    }
    
    // Check if engaged
    explicit operator bool() const noexcept { return engaged_; }
};
 
// Usage
auto file = UniqueResource(
    fopen("data.txt", "r"), 
    [](FILE* f) { if (f) fclose(f); }
);
 
if (file) {
    // Use file.get()...
}
 
// Clean interface for specific resources
class Socket {
    int fd_;
    
public:
    explicit Socket(const char* host, int port) {
        fd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (fd_ < 0) throw NetworkError("socket creation failed");
        
        // Connect...
        if (connect(fd_, /* ... */) < 0) {
            close(fd_);  // Must clean up before throwing
            throw NetworkError("connection failed");
        }
    }
    
    ~Socket() {
        if (fd_ >= 0) {
            close(fd_);
        }
    }
    
    // Non-copyable, movable
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;
    
    Socket(Socket&& other) noexcept : fd_(other.fd_) {
        other.fd_ = -1;
    }
    
    Socket& operator=(Socket&& other) noexcept {
        if (this != &other) {
            if (fd_ >= 0) close(fd_);
            fd_ = other.fd_;
            other.fd_ = -1;
        }
        return *this;
    }
    
    // Interface
    ssize_t send(const void* data, size_t len) {
        return ::send(fd_, data, len, 0);
    }
    
    ssize_t recv(void* buffer, size_t len) {
        return ::recv(fd_, buffer, len, 0);
    }
};

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

// ANTI-PATTERN 1: Two-phase initialization
class BadResource {
    FILE* file_ = nullptr;
public:
    BadResource() = default;  // Does nothing
    
    bool init(const char* path) {  // Might fail
        file_ = fopen(path, "r");
        return file_ != nullptr;
    }
    
    ~BadResource() {
        if (file_) fclose(file_);  // OK, but object existed in invalid state
    }
};
// Problem: Object exists before init(), init() might not be called
 
// CORRECT: Single-phase initialization
class GoodResource {
    FILE* file_;
public:
    explicit GoodResource(const char* path) 
        : file_(fopen(path, "r")) 
    {
        if (!file_) throw std::runtime_error("Failed to open");
    }
    ~GoodResource() { fclose(file_); }  // Always valid file
};
 
 
// ANTI-PATTERN 2: Unnamed temporary
void badLocking() {
    std::lock_guard<std::mutex>(mutex_);  // BUG! Temporary destroyed immediately!
    // Not actually locked here!
    doThingsWhileThinkingWeAreLocked();
}
 
// CORRECT: Named RAII object
void goodLocking() {
    std::lock_guard<std::mutex> lock(mutex_);  // Named - lives to end of scope
    doThingsWhileActuallyLocked();
}
 
 
// ANTI-PATTERN 3: Constructor exception leaks resources
class LeakyOnException {
    FILE* file_;
    Connection* conn_;
public:
    LeakyOnException(const char* path, const char* url) {
        file_ = fopen(path, "r");
        if (!file_) throw std::runtime_error("File open failed");
        
        conn_ = new Connection(url);  // If this throws...
        // file_ is never closed! Memory leak!
    }
    ~LeakyOnException() {
        delete conn_;
        fclose(file_);
    }
};
 
// CORRECT: Use RAII members
class SafeOnException {
    std::unique_ptr<std::FILE, decltype(&fclose)> file_;
    std::unique_ptr<Connection> conn_;
public:
    SafeOnException(const char* path, const char* url)
        : file_(fopen(path, "r"), &fclose)
        , conn_(std::make_unique<Connection>(url))  // If throws...
    {
        if (!file_) throw std::runtime_error("File open failed");
        // file_ is destroyed by its own destructor!
    }
    // No manual destructor needed - Rule of Zero
};