Smart Pointer trong C++ – Quản lý bộ nhớ động một cách an toàn

Một trong những vấn đề gây đau đầu nhất trong C++ là quản lý bộ nhớ động bằng new/delete. Khi bạn cấp phát thủ công, bạn phải tự chịu trách nhiệm giải phóng đúng lúc. Bất kỳ sự sơ suất nào cũng có thể dẫn đến:

• Rò rỉ bộ nhớ (memory leak)
• Truy cập vùng nhớ đã bị thu hồi (use-after-free)
• Gọi delete nhiều lần (double delete)
• Crash chương trình ở runtime

C++ hiện đại giải quyết triệt để vấn đề này bằng một công cụ mạnh mẽ và an toàn: smart pointer.

Smart pointer là gì?

Smart pointer (con trỏ thông minh) là một lớp (class) được thiết kế để hoạt động giống như con trỏ thông thường, nhưng được tích hợp logic tự động giải phóng bộ nhớ khi con trỏ không còn được sử dụng nữa.

Nói cách khác, smart pointer bọc (wrap) quanh con trỏ thô (T*) và sử dụng RAII để đảm bảo rằng:

• Bộ nhớ được cấp phát bằng new sẽ luôn được delete
• Không cần gọi delete thủ công
• Không bao giờ bị rò rỉ bộ nhớ nếu bạn dùng đúng cách

Các loại smart pointer trong C++ (chuẩn C++11+)

C++ chuẩn hóa 3 loại smart pointer chính trong header <memory>:

1. std::unique_ptr<T>

• Mỗi con trỏ chỉ có một chủ sở hữu duy nhất.
• Không thể copy, chỉ có thể move.
• Khi unique_ptr bị hủy, con trỏ bên trong sẽ được delete.

#include <memory>

void demo() {
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    // không cần delete
} // tự động gọi delete tại đây

2. std::shared_ptr<T>

• Cho phép nhiều smart pointer cùng sở hữu một đối tượng.
• Bộ đếm tham chiếu (reference count) sẽ tăng/giảm tự động.
• Đối tượng bị delete khi không còn ai giữ nó.

#include <memory>

std::shared_ptr<int> create() {
    return std::make_shared<int>(100);
}

void use() {
    auto a = create();
    auto b = a; // cả hai cùng sở hữu
} // khi cả `a` và `b` bị hủy, giá trị mới được delete

3. std::weak_ptr<T>

• Không sở hữu đối tượng, nhưng có thể quan sát một shared_ptr.
• Không làm tăng reference count.
• Dùng để tránh vòng tham chiếu (circular reference).

#include <memory>

void demo() {
    std::shared_ptr<int> sp = std::make_shared<int>(50);
    std::weak_ptr<int> wp = sp;

    if (auto locked = wp.lock()) {
        // dùng locked như shared_ptr
    }
}

So sánh unique_ptr và shared_ptr

Sự khác biệt giữa hai loại smart pointer phổ biến nhất nằm ở quyền sở hữu:

Thuộc tính	unique_ptr	shared_ptr
Sở hữu duy nhất	Có	Không, dùng chung được
Có thể copy	Không	Có
Có thể move	Có	Có
Chi phí quản lý	Rất thấp	Cao hơn (do đếm tham chiếu)
An toàn vòng lặp	An toàn	Cần thêm weak_ptr

Quy tắc:

• Dùng unique_ptr mặc định nếu không cần chia sẻ quyền sở hữu.
• Chỉ dùng shared_ptr khi thực sự cần chia sẻ.
• Nếu có khả năng tạo vòng lặp sở hữu (như trong cây, đồ thị), hãy dùng weak_ptr để phá vòng.

Tại sao smart pointer là phần mở rộng của RAII?

Như bạn đã biết từ bài viết trước, RAII là cách gắn tài nguyên vào vòng đời của một biến. Smart pointer chính là ví dụ điển hình cho RAII: khi smart pointer bị hủy, con trỏ bên trong cũng được hủy theo.

Ví dụ:

class MyClass {
public:
    MyClass() { std::cout << "Construct\n"; }
    ~MyClass() { std::cout << "Destruct\n"; }
};

void foo() {
    std::unique_ptr<MyClass> obj = std::make_unique<MyClass>();
} // "Destruct" được in ra, đảm bảo obj bị huỷ đúng lúc

Bạn không cần lo lắng về delete – đó chính là sức mạnh của RAII thông qua smart pointer.

Những lỗi thường gặp khi chưa dùng smart pointer

Trước khi có smart pointer, cách dùng truyền thống với new/delete rất dễ gây lỗi:

void badExample() {
    MyClass* p = new MyClass();
    if (some_condition) return; // quên delete!
    delete p;
}

Nếu bạn quên delete, bộ nhớ sẽ bị giữ lại mãi mãi. Nếu bạn delete nhầm 2 lần, chương trình có thể crash.

Smart pointer loại bỏ hoàn toàn các rủi ro đó bằng cách gắn delete vào destructor, và đảm bảo destructor được gọi đúng lúc.

Khi nào không nên dùng smart pointer?

Mặc dù smart pointer là công cụ mạnh mẽ, nhưng cũng có lúc không nên lạm dụng:

• Khi bạn không cần cấp phát động (dùng biến cục bộ là đủ)
• Khi ownership không rõ ràng, dễ dẫn tới logic sai
• Khi hiệu suất là yếu tố tối quan trọng (như trong game engine hoặc hệ thống nhúng cực kỳ giới hạn tài nguyên)

Nhưng trong phần lớn ứng dụng C++ hiện đại, smart pointer là lựa chọn mặc định cho quản lý bộ nhớ heap.

Tổng kết

Smart pointer trong C++ là công cụ mạnh mẽ giúp bạn:

• Quản lý con trỏ an toàn, không cần delete
• Áp dụng RAII để tự động thu hồi tài nguyên
• Tránh rò rỉ bộ nhớ, vòng lặp tham chiếu, lỗi truy cập vùng nhớ sai
• Viết code rõ ràng, ngắn gọn, dễ bảo trì

Bạn chỉ cần nhớ 3 loại:

• unique_ptr<T> – dùng mặc định
• shared_ptr<T> – khi cần chia sẻ sở hữu
• weak_ptr<T> – để quan sát, tránh vòng tham chiếu