Smartpointer Trong C++

I. Smartpointer là gì. Tại sao nên sử dụng smartpointer

Smart pointer là một khái niệm trong lập trình, thường được sử dụng trong các ngôn ngữ như C++ để quản lý việc cấp phát và giải phóng bộ nhớ động một cách an toàn và tự động.

Trong C++, khi bạn cấp phát bộ nhớ động bằng từ khóa new, bạn cần chịu trách nhiệm giải phóng bộ nhớ này bằng cách sử dụng từ khóa delete khi bạn không cần dùng đến nữa. Tuy nhiên, việc quản lý bộ nhớ thủ công như vậy có thể dẫn đến các vấn đề như quên giải phóng bộ nhớ, giải phóng bộ nhớ quá sớm hoặc giải phóng bộ nhớ hai lần.

Smart pointer giúp giải quyết các vấn đề này bằng cách cung cấp một giao diện trực quan và tự động quản lý bộ nhớ động. Smart pointer là một lớp đặc biệt, hoạt động như một con trỏ thông thường, nhưng có thêm các tính năng bổ sung. Các smart pointer phổ biến trong C++ bao gồm std::unique_ptr, std::shared_ptr và std::weak_ptr.

• – std::unique_ptr cho phép quản lý một đối tượng động duy nhất. Khi đối tượng không còn cần thiết, bộ nhớ sẽ tự động được giải phóng.
  – std::shared_ptr cho phép quản lý một đối tượng động được chia sẻ bởi nhiều smart pointer. Nó duy trì một đếm tham chiếu và chỉ giải phóng bộ nhớ khi không còn smart pointer nào sử dụng nó.
  – std::weak_ptr là một phiên bản yếu hơn của std::shared_ptr và thường được sử dụng để tránh vấn đề vòng lặp tham chiếu (circular reference) giữa các đối tượng.

Việc sử dụng smart pointer giúp giảm rủi ro liên quan đến quản lý bộ nhớ và làm cho mã nguồn dễ đọc và bảo trì hơn.

II. Cú Pháp Khai Báo Smartpointer

Trong C++, để khai báo một smart pointer, bạn cần bao bọc kiểu dữ liệu của đối tượng cần quản lý bên trong cặp dấu nhọn (`<>`). Dưới đây là cú pháp để khai báo các smart pointer phổ biến:

1. td::unique_ptr: Để khai báo một std::unique_ptr, bạn cần chỉ định kiểu dữ liệu của đối tượng mà smart pointer sẽ quản lý.

std::unique_ptr<T> ptr;  // Khai báo một unique_ptr quản lý kiểu T

2. std::shared_ptr: Để khai báo một std::shared_ptr, bạn cũng cần chỉ định kiểu dữ liệu của đối tượng.

std::shared_ptr<T> ptr;  // Khai báo một shared_ptr quản lý kiểu T

3. std::weak_ptr: Cũng tương tự, để khai báo một std::weak_ptr, bạn cần chỉ định kiểu dữ liệu của đối tượng.

std::weak_ptr<T> ptr;  // Khai báo một weak_ptr quản lý kiểu T

Trong tất cả các trường hợp trên, `T` đại diện cho kiểu dữ liệu của đối tượng mà smart pointer sẽ quản lý. Bạn có thể thay thế `T` bằng bất kỳ kiểu dữ liệu nào phù hợp với nhu cầu của bạn.

Bên cạnh việc khai báo, bạn cũng có thể khởi tạo một smart pointer cùng lúc với khai báo bằng cách truyền đối tượng được cấp phát động vào smart pointer. Ví dụ:

std::unique_ptr<int> ptr(new int(42));  // Khai báo và khởi tạo unique_ptr quản lý một đối tượng int động
Lưu ý rằng `std::unique_ptr` yêu cầu con trỏ raw (raw pointer) như đối số cho constructor, trong khi `std::shared_ptr` và `std::weak_ptr` có thể khởi tạo từ một con trỏ raw hoặc từ một smart pointer khác.

III. Sự khác biệt giữa unique_ptr, shared_ptr, shared_ptr

Dưới đây là ví dụ minh họa về sự khác biệt giữa `std::unique_ptr`, `std::shared_ptr` và `std::weak_ptr` trong C++:

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called!" << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called!" << std::endl;
    }
};

int main() {
    // Sử dụng std::unique_ptr
    {
        std::unique_ptr<MyClass> uniquePtr(new MyClass());
        // std::unique_ptr sở hữu đối tượng MyClass

        // Sử dụng uniquePtr như một con trỏ thông thường
        uniquePtr->someMethod();

        // uniquePtr tự động giải phóng bộ nhớ khi ra khỏi phạm vi
    }

    // Sử dụng std::shared_ptr
    {
        std::shared_ptr<MyClass> sharedPtr1(new MyClass());
        // sharedPtr1 sở hữu đối tượng MyClass

        std::shared_ptr<MyClass> sharedPtr2 = sharedPtr1;
        // sharedPtr2 cũng sở hữu đối tượng MyClass

        // Sử dụng sharedPtr1 và sharedPtr2 như các con trỏ thông thường
        sharedPtr1->someMethod();
        sharedPtr2->someMethod();

        // sharedPtr1 và sharedPtr2 vẫn giữ quyền sở hữu cho đến khi cả hai ra khỏi phạm vi

    }

    // Sử dụng std::weak_ptr
    {
        std::shared_ptr<MyClass> sharedPtr(new MyClass());
        // sharedPtr sở hữu đối tượng MyClass

        std::weak_ptr<MyClass> weakPtr = sharedPtr;
        // weakPtr không sở hữu đối tượng MyClass, chỉ trỏ tới sharedPtr

        // Sử dụng weakPtr để kiểm tra xem đối tượng có còn sống hay không
        if (auto sharedPtrLocked = weakPtr.lock()) {
            // Đối tượng vẫn còn sống
            sharedPtrLocked->someMethod();
        } else {
            // Đối tượng đã bị giải phóng
        }

        // sharedPtr vẫn giữ quyền sở hữu, nhưng weakPtr không còn trỏ tới đối tượng khi sharedPtr giải phóng đối tượng

    }

    return 0;
}

Trong ví dụ trên:

• std::unique_ptr được sử dụng để quản lý một đối tượng MyClass duy nhất. Nó sở hữu đối tượng và tự động giải phóng bộ nhớ khi ra khỏi phạm vi.
• std::shared_ptr được sử dụng để quản lý một đối tượng MyClass được chia sẻ bởi nhiều smart pointer. Nó duy trì một đếm tham chiếu và chỉ giải phóng bộ nhớ khi không còn smart pointer nào sử dụng nó.
• std::weak_ptr là một phiên bản yếu hơn của std::shared_ptr. Nó không sở hữu đối tượng, chỉ trỏ tới một std::shared_ptr. Bạn có thể dùng std::weak_ptr để kiểm tra xem đối tượng còn sống hay đã bị giải phóng. Khi cần sử dụng đối tượng, bạn cần khóa std::weak_ptr thành std::shared_ptr bằng phương thức lock().

Lưu ý rằng việc in ra thông báo trong hàm constructor và destructor chỉ để minh họa việc giải phóng bộ nhớ. Khi smart pointer ra khỏi phạm vi, destructor sẽ được gọi tự động để giải phóng bộ nhớ.