RAII và quản lý bộ nhớ

Sau khi đã học về stack, heap, con trỏ, và smart pointer, bài này tổng hợp lại bức tranh toàn cảnh về cách C++ quản lý bộ nhớ - và giới thiệu nguyên lý RAII, nền tảng triết lý quản lý tài nguyên của toàn bộ ngôn ngữ.

Nhắc lại: Stack và Heap

	Stack	Heap
Cấp phát	Tự động (khai báo biến thông thường)	Thủ công (new) hoặc qua smart pointer
Giải phóng	Tự động khi ra khỏi scope	Thủ công (delete) hoặc tự động qua smart pointer
Tốc độ	Rất nhanh	Chậm hơn
Rủi ro	Gần như không có	Rò rỉ bộ nhớ, dangling pointer, double free

RAII là gì?

RAII (Resource Acquisition Is Initialization) là nguyên lý cốt lõi của C++: gắn vòng đời của một tài nguyên (bộ nhớ, file, kết nối mạng, khóa mutex…) với vòng đời của một đối tượng. Tài nguyên được cấp phát trong constructor (khi đối tượng được tạo) và tự động giải phóng trong destructor (khi đối tượng bị hủy) - dù chương trình kết thúc bình thường hay có exception xảy ra.

Bạn đã thấy RAII hoạt động ở nhiều nơi mà có thể không để ý:

#include <memory>
#include <fstream>
#include <iostream>

void demo() {
    auto ptr = std::make_unique<int>(42);   // RAII: bộ nhớ tự giải phóng khi ptr ra khỏi scope
    std::ofstream file("data.txt");          // RAII: file tự đóng khi file ra khỏi scope

    std::cout << *ptr << std::endl;
} // Cả ptr và file đều tự động dọn dẹp tại đây, không cần code thủ công

Vì sao RAII quan trọng đến vậy?

So sánh cách quản lý tài nguyên thủ công với RAII khi có khả năng xảy ra lỗi:

// KHÔNG dùng RAII - rất dễ rò rỉ bộ nhớ nếu có exception
void risky_function() {
    int* data = new int[1000];

    do_something_that_might_throw(); // Nếu ném exception ở đây...

    delete[] data; // ...dòng này KHÔNG BAO GIỜ được chạy tới! Rò rỉ bộ nhớ.
}

// DÙNG RAII - luôn an toàn
void safe_function() {
    auto data = std::make_unique<int[]>(1000);

    do_something_that_might_throw(); // Nếu ném exception ở đây,

} // ...unique_ptr VẪN giải phóng bộ nhớ khi "unwinding" qua scope này

Đây là lý do vì sao C++ hiện đại gần như luôn ưu tiên các lớp bao bọc tài nguyên tự động (std::vector, std::string, std::unique_ptr, std::ofstream…) thay vì thao tác trực tiếp với tài nguyên cấp thấp (new/delete, con trỏ file thô).

Bức tranh toàn cảnh: từ con trỏ thô đến smart pointer

new/delete thủ công  →  Dễ quên delete, dễ rò rỉ bộ nhớ, dễ lỗi khi có exception
        ↓
Smart pointer (RAII) →  Tự động giải phóng đúng lúc, an toàn với exception
        ↓
std::vector, std::string, std::map...  →  RAII áp dụng cho toàn bộ dữ liệu, không chỉ bộ nhớ đơn lẻ

Toàn bộ các container mà bạn đã học (vector, map, set, string) đều tự quản lý bộ nhớ động bên trong theo nguyên lý RAII - đây là lý do bạn chưa từng phải gọi delete khi dùng chúng.

Quy tắc thực hành

• Ưu tiên biến trên stack (khai báo bình thường) bất cứ khi nào có thể - đơn giản và an toàn nhất
• Khi cần bộ nhớ động, ưu tiên std::vector/std::string/smart pointer thay vì new/delete trực tiếp
• Chỉ dùng new/delete thủ công khi thực sự cần kiểm soát chi tiết, và luôn đảm bảo mọi đường thực thi (kể cả khi có exception) đều giải phóng đúng cách

Tổng kết

• RAII gắn vòng đời tài nguyên với vòng đời đối tượng: cấp phát trong constructor, giải phóng trong destructor
• RAII đảm bảo tài nguyên luôn được giải phóng đúng cách, kể cả khi có exception xảy ra giữa chừng
• std::vector, std::string, smart pointer, std::ofstream… đều được xây dựng dựa trên nguyên lý RAII
• Trong C++ hiện đại, hiếm khi cần gọi new/delete trực tiếp - hãy để các lớp RAII làm việc đó cho bạn