This programming guide is only available in Vietnamese. Switch to Vietnamese to read the full article.

Trong lập trình C cổ điển, cấp phát bộ nhớ động bằng malloc yêu cầu bạn phải nhớ gọi free. Việc quên giải phóng bộ nhớ dẫn đến lỗi rò rỉ bộ nhớ (Memory Leak) kinh điển khiến phần mềm ngốn sạch RAM hệ thống theo thời gian. Modern C++ đã giải quyết triệt để vấn đề này bằng cách giới thiệu Smart Pointers (Con trỏ thông minh) hoạt động dựa trên triết lý RAII: tự động thu hồi vùng nhớ Heap khi con trỏ ra khỏi scope.

1. Các loại Smart Pointers thông dụng & Cơ chế hoạt động chi tiết

std::unique_ptr — Quy chế sở hữu độc quyền & Không có Overhead

std::unique_ptr đảm bảo chỉ có duy nhất một con trỏ được phép sở hữu vùng nhớ Heap tại một thời điểm. Khi con trỏ này rời khỏi phạm vi hoạt động (scope), vùng nhớ Heap mà nó trỏ tới sẽ lập tức được giải phóng tự động.

• Cơ chế Zero-Overhead: Ở mức độ bộ nhớ, unique_ptr không hề tốn thêm bất kỳ byte RAM nào so với con trỏ thô (Raw Pointer) - nó chỉ là một con trỏ 8 bytes. Trình biên dịch C++ tự động tạo mã lệnh hủy delete khi đối tượng rời khỏi scope.
• Ngăn chặn sao chép: unique_ptr xóa bỏ hoàn toàn Constructor sao chép (Copy Constructor) để tránh tình trạng nhiều con trỏ cùng sở hữu một tài nguyên thô dẫn đến lỗi Double Free.
• Chuyển quyền sở hữu (Move Semantics): Bạn chỉ có thể chuyển giao vùng nhớ sang con trỏ khác bằng lệnh std::move(). Sau lệnh này, con trỏ cũ bị gán về nullptr.

std::shared_ptr — Đồng sở hữu thông qua Control Block

std::shared_ptr cho phép nhiều con trỏ cùng quản lý và chia sẻ một vùng nhớ Heap chung. Khác với `unique_ptr`, `shared_ptr` chiếm dụng gấp đôi bộ nhớ trên Stack (16 bytes trên hệ thống 64-bit) vì nó quản lý đồng thời hai con trỏ:

1. Con trỏ trỏ trực tiếp tới đối tượng dữ liệu được quản lý trên Heap.
2. Con trỏ trỏ tới Control Block (Khối điều khiển) - một phân vùng nhớ động chung trên Heap được tạo ra bởi thư viện STL.

shared_ptr trên Stack:
┌──────────────────────────┐          ┌─────────────────────────────────┐
│ Pointer to Object        ├─────────►│ Đối tượng thực tế (Managed Obj) │
├──────────────────────────┤          └─────────────────────────────────┘
│ Pointer to Control Block ├────┐
└──────────────────────────┘    │     Khối điều khiển (Control Block trên Heap):
                                └────►┌─────────────────────────────────┐
                                      │ Strong Ref Count (Bộ đếm shared)│
                                      ├─────────────────────────────────┤
                                      │ Weak Ref Count (Bộ đếm weak)    │
                                      ├─────────────────────────────────┤
                                      │ Custom Deleter / Allocator      │
                                      └─────────────────────────────────┘
              

Control Block chứa các thông số: bộ đếm tham chiếu mạnh (Strong Ref Count), bộ đếm tham chiếu yếu (Weak Ref Count) và hàm hủy tự chọn (Custom Deleter). Các bộ đếm này được thiết kế thread-safe (sử dụng toán tử nguyên tử atomic) để đảm bảo an toàn khi tăng/giảm đếm đa luồng. Khi Strong Ref Count chạm mốc 0, vùng nhớ của đối tượng sẽ được giải phóng lập tức.

Mẹo tối ưu hóa hiệu năng: std::make_shared

Nếu bạn khai báo: std::shared_ptr<Widget> ptr(new Widget());, C++ buộc phải thực hiện 2 lần cấp phát động trên Heap riêng biệt (một lần cho bản thân Widget và một lần cho `Control Block`).

Hãy luôn ưu tiên sử dụng: auto ptr = std::make_shared<Widget>();. Hàm này thực hiện duy nhất 1 lần cấp phát Heap, gộp chung Widget và Control Block nằm liền kề nhau trên cùng một khối nhớ. Cách này giúp tăng tốc độ xử lý và cải thiện tính lân cận dữ liệu (Cache Locality).

std::weak_ptr — Giải quyết hiểm họa Tham chiếu vòng (Circular Reference)

Một điểm yếu nguy hiểm của shared_ptr là hiện tượng Circular Reference (Tham chiếu vòng). Giả sử ta có hai đối tượng A và B chứa con trỏ shared_ptr trỏ chéo vào nhau. Khi hàm thoát, cả hai đối tượng đều giảm đếm nhưng không bao giờ đạt mốc 0 (do còn con trỏ từ đối tượng kia trỏ tới). Kết quả: cả A và B bị kẹt lại trên Heap mãi mãi, gây rò rỉ bộ nhớ nghiêm trọng.

Để phá vỡ vòng lặp này, ta thay thế một trong hai liên kết bằng std::weak_ptr:

• weak_ptr chỉ liên kết quan sát đối tượng chứ không nắm quyền sở hữu.
• Nó chỉ làm tăng bộ đếm Weak Ref Count trong Control Block, hoàn toàn không làm tăng Strong Ref Count.
• Nhờ vậy, đối tượng có thể bị giải phóng một cách bình thường khi Strong Ref Count đạt 0. Trước khi truy xuất đối tượng từ `weak_ptr`, ta gọi phương thức lock() để chuyển đổi tạm thời nó thành một `shared_ptr` hợp lệ.

2. Góc V8 Engine: Hệ thống Handles trong C++ quản lý JS như thế nào?

Bộ dọn rác (Garbage Collector - GC) của Google V8 Engine hoạt động trên bộ nhớ Heap của JavaScript. Do V8 được viết bằng C++, để bảo vệ các đối tượng JS không bị GC dọn dẹp nhầm khi mã C++ vẫn đang xử lý, V8 thiết kế một hệ thống Handles đặc thù hoạt động tương tự như Smart Pointers trong C++:

• v8::Local<T>: Tương tự như unique_ptr trong một phạm vi nhỏ. Nó được quản lý bởi một `v8::HandleScope`. Khi `HandleScope` bị hủy, toàn bộ các Local Handles nằm trong đó sẽ tự động được dọn dẹp khỏi danh sách quản lý của GC.
• v8::Persistent<T>: Tương tự như shared_ptr, cho phép đối tượng JS sống thọ hơn, vượt ra ngoài phạm vi của các hàm cục bộ C++. Chúng ta phải giải phóng nó bằng tay hoặc cấu hình weak callback tương tự như `std::weak_ptr` để GC tự động giải phóng đối tượng khi không còn tham chiếu nào từ JavaScript.

3. Code thực hành: smart_pointers.cpp

Hãy cùng chạy thử chương trình sau để nhìn thấy vòng đời tự động giải phóng bộ nhớ của các smart pointers:

#include <iostream>
#include <memory>
#include <string>

class V8Context {
public:
    std::string name;
    V8Context(std::string n) : name(n) {
        std::cout << "[V8Context] Đã khởi tạo Context: " << name << std::endl;
    }
    ~V8Context() {
        std::cout << "[V8Context] Đã giải phóng Context: " << name << std::endl;
    }
    void runScript(std::string script) {
        std::cout << "[" << name << "] Chạy script: " << script << std::endl;
    }
};

void demoUniquePtr() {
    std::cout << "\n--- Demo std::unique_ptr (Sở hữu độc quyền) ---" << std::endl;
    // unique_ptr tự động giải phóng đối tượng khi biến đi ra khỏi scope
    std::unique_ptr<V8Context> ctx1 = std::make_unique<V8Context>("Isolated_Context_1");
    ctx1->runScript("let a = 10;");

    // Không thể copy unique_ptr (Dòng này sẽ gây lỗi biên dịch):
    // std::unique_ptr<V8Context> ctx2 = ctx1;

    // Chỉ có thể chuyển quyền sở hữu (Move Ownership)
    std::unique_ptr<V8Context> ctx2 = std::move(ctx1);
    if (!ctx1) {
        std::cout << "ctx1 bây giờ là nullptr (đã chuyển quyền sang ctx2)." << std::endl;
    }
    ctx2->runScript("let b = 20;");
}

void demoSharedPtr() {
    std::cout << "\n--- Demo std::shared_ptr (Đồng sở hữu) ---" << std::endl;
    std::shared_ptr<V8Context> sharedCtx1 = std::make_shared<V8Context>("Shared_Engine_Context");
    std::cout << "Số lượng người sở hữu (Reference Count): " << sharedCtx1.use_count() << std::endl;

    {
        std::shared_ptr<V8Context> sharedCtx2 = sharedCtx1; // Copy được shared_ptr
        std::cout << "Copy thành công. Số lượng người sở hữu: " << sharedCtx1.use_count() << std::endl;
        sharedCtx2->runScript("const pi = 3.14;");
        // Thoát khỏi scope này, sharedCtx2 bị hủy nhưng sharedCtx1 vẫn giữ đối tượng
    }
    
    std::cout << "Sau scope con. Số lượng người sở hữu: " << sharedCtx1.use_count() << std::endl;
}

int main() {
    demoUniquePtr();
    demoSharedPtr();
    std::cout << "\n--- Kết thúc main (Các Smart Pointer tự động thu hồi bộ nhớ) ---" << std::endl;
    return 0;
}

4. unique_ptr Custom Deleter: Quản lý tài nguyên đặc biệt

Mặc định, std::unique_ptr sử dụng delete hoặc delete[] để giải phóng bộ nhớ. Nhưng nếu bạn quản lý các tài nguyên khác (ví dụ: FILE pointers, sockets, hoặc các đối tượng được cấp phát bằng hàm tùy chỉnh), bạn cần cung cấp một Custom Deleter - một hàm được gọi khi unique_ptr bị hủy:

#include <iostream>
#include <memory>
#include <cstdio>

// Custom deleter cho FILE*
void closeFile(FILE* f) {
    if (f) {
        std::cout << "[Deleter] Closing file" << std::endl;
        fclose(f);
    }
}

// Custom deleter cho array
struct ArrayDeleter {
    void operator()(int* ptr) const {
        std::cout << "[ArrayDeleter] Freeing array via custom function" << std::endl;
        delete[] ptr;
    }
};

int main() {
    // Ví dụ 1: Custom deleter cho FILE*
    {
        std::unique_ptr<FILE, decltype(&closeFile)> file(
            fopen("test.txt", "w"),
            &closeFile
        );
        if (file) {
            fprintf(file.get(), "Hello, World!\n");
        }
        // Khi thoát scope, closeFile() sẽ được gọi tự động
    }

    // Ví dụ 2: Custom deleter là functor
    {
        std::unique_ptr<int[], ArrayDeleter> arr(new int[100]);
        arr[0] = 42;
        // Khi thoát scope, ArrayDeleter::operator() sẽ được gọi
    }

    return 0;
}

5. std::make_shared vs shared_ptr Constructor: Tối ưu hóa Control Block

Khi bạn sử dụng std::shared_ptr<T>(new T()), hệ thống phải cấp phát hai lần trên Heap riêng biệt - một lần cho object T và một lần cho Control Block. Điều này tốn kém bộ nhớ và gây ra nhiều lần truy cập Heap.

Ngược lại, `std::make_shared<T>()` thực hiện cấp phát duy nhất - nó gộp object T và Control Block vào một khối nhớ liền kề. Điều này cải thiện Cache Locality (tính lân cận dữ liệu) và tốc độ xử lý:

#include <iostream>
#include <memory>

class DatabaseConnection {
public:
    std::string connectionString;
    DatabaseConnection(const std::string& conn) : connectionString(conn) {
        std::cout << "[DB] Connected to: " << conn << std::endl;
    }
    ~DatabaseConnection() {
        std::cout << "[DB] Disconnected" << std::endl;
    }
};

int main() {
    // BAD: Two separate Heap allocations
    // Allocation 1: DatabaseConnection object
    // Allocation 2: Control Block
    std::shared_ptr<DatabaseConnection> db1(
        new DatabaseConnection("server1.db")
    );

    // GOOD: Single Heap allocation
    // Both object and Control Block allocated together
    auto db2 = std::make_shared<DatabaseConnection>("server2.db");

    std::cout << "db2 reference count: " << db2.use_count() << std::endl;

    // Memory layout comparison:
    std::cout << "\ndb1 memory layout (Two allocations):" << std::endl;
    std::cout << "  Object address: " << db1.get() << std::endl;

    std::cout << "\ndb2 memory layout (Single allocation):" << std::endl;
    std::cout << "  Object address: " << db2.get() << std::endl;

    return 0;
}

6. std::weak_ptr: Phá vỡ Circular Reference

Một hiểm họa của `shared_ptr` là Circular Reference (Tham chiếu vòng): khi hai hay nhiều đối tượng chứa `shared_ptr` chỉ tay vào nhau. Vì mỗi liên kết tăng bộ đếm tham chiếu, không bao giờ đủ điều kiện để gọi destructor, dẫn đến rò rỉ bộ nhớ toàn bộ.

std::weak_ptr là giải pháp: nó hoạt động giống `shared_ptr` nhưng không nắm quyền sở hữu. Nó chỉ quan sát đối tượng mà không ảnh hưởng tới Strong Ref Count:

#include <iostream>
#include <memory>

class Parent;
class Child;

// PROBLEM: Circular Reference
class ParentBad {
public:
    std::shared_ptr<Child> child;
    ~ParentBad() { std::cout << "[Parent] Destructor" << std::endl; }
};

class ChildBad {
public:
    std::shared_ptr<ParentBad> parent;  // Strong reference - creates cycle!
    ~ChildBad() { std::cout << "[Child] Destructor" << std::endl; }
};

// SOLUTION: Use weak_ptr to break cycle
class Parent {
public:
    std::shared_ptr<Child> child;
    ~Parent() { std::cout << "[Parent] Destructor called" << std::endl; }
};

class Child {
public:
    std::weak_ptr<Parent> parent;  // Weak reference - does NOT keep parent alive
    ~Child() { std::cout << "[Child] Destructor called" << std::endl; }
};

int main() {
    std::cout << "--- Creating Parent-Child with weak_ptr (CORRECT) ---" << std::endl;
    {
        auto parent = std::make_shared<Parent>();
        auto child = std::make_shared<Child>();

        parent->child = child;
        child->parent = parent;  // Weak reference - no cycle!

        std::cout << "Parent ref count: " << parent.use_count() << std::endl;
        std::cout << "Child ref count: " << child.use_count() << std::endl;

        // Access parent through weak_ptr
        if (auto p = child->parent.lock()) {  // lock() converts weak_ptr to shared_ptr
            std::cout << "Child successfully accessed parent" << std::endl;
        }
    }
    std::cout << "Both Parent and Child destructors called!" << std::endl;

    return 0;
}

Circular Reference Problem vs Solution:

PROBLEM (Circular Reference):
┌──────────────────────┐         ┌──────────────────────┐
│ Parent               │         │ Child                │
├──────────────────────┤         ├──────────────────────┤
│ shared_ptr child ────┼────────►│ shared_ptr parent ───┼──┐
│ ref_count: 2         │◄────────│ ref_count: 2         │  │
└──────────────────────┘         └──────────────────────┘  │
         ^                                                   │
         └───────────────────────────────────────────────────┘

Result: ref_count never reaches 0, memory leak!

SOLUTION (Use weak_ptr):
┌──────────────────────┐         ┌──────────────────────┐
│ Parent               │         │ Child                │
├──────────────────────┤         ├──────────────────────┤
│ shared_ptr child ────┼────────►│ weak_ptr parent ─────┼───┐
│ ref_count: 1         │         │ ref_count: 1         │   │
└──────────────────────┘         └──────────────────────┘   │
                                                             │
Parent ref_count decreases to 0, destructor called!
              

7. Exception Safety & RAII Pattern

Smart Pointers là nền tảng của RAII (Resource Acquisition Is Initialization) pattern - một cách tiếp cận quản lý tài nguyên mà đảm bảo an toàn kể cả khi có exception xảy ra. Khi một exception được ném, các biến cục bộ được hủy theo thứ tự ngược lại (stack unwinding), và Smart Pointers sẽ tự động giải phóng tài nguyên:

#include <iostream>
#include <memory>
#include <stdexcept>

class DatabaseConnection {
public:
    DatabaseConnection() {
        std::cout << "[DB] Connection opened" << std::endl;
    }
    ~DatabaseConnection() {
        std::cout << "[DB] Connection closed (automatic cleanup)" << std::endl;
    }
    void query(const std::string& sql) {
        if (sql.empty()) {
            throw std::runtime_error("Empty SQL query!");
        }
        std::cout << "[DB] Executing: " << sql << std::endl;
    }
};

void processDataWithException() {
    auto db = std::make_unique<DatabaseConnection>();

    try {
        db->query("SELECT * FROM users");
        db->query("");  // This will throw!
        db->query("SELECT * FROM products");  // Never reached
    } catch (const std::exception& e) {
        std::cout << "[Error] Caught exception: " << e.what() << std::endl;
        // Even though exception occurred, 'db' destructor will be called
        // when exiting this function, closing connection automatically
    }
}

int main() {
    std::cout << "--- Exception Safety with Smart Pointers ---" << std::endl;
    processDataWithException();
    std::cout << "Function ended. Database connection cleaned up!" << std::endl;
    return 0;
}

8. Migrating from Raw Pointers: Refactoring Legacy Code

Nếu bạn có code cũ viết với raw pointers (C-style), việc chuyển sang Smart Pointers đòi hỏi thay đổi logic và cấu trúc. Dưới đây là một số mẫu phổ biến:

#include <iostream>
#include <memory>
#include <vector>

class Image {
public:
    int width, height;
    Image(int w, int h) : width(w), height(h) {
        std::cout << "[Image] Created " << w << "x" << h << std::endl;
    }
    ~Image() {
        std::cout << "[Image] Destroyed" << std::endl;
    }
};

// OLD WAY (Raw pointers - dangerous!)
/*
void processImagesOld() {
    Image* img1 = new Image(800, 600);
    Image* img2 = new Image(1024, 768);

    // ... process images ...

    delete img1;  // Easy to forget!
    delete img2;  // If exception occurs, these never execute
}
*/

// NEW WAY (Smart pointers - safe!)
void processImagesNew() {
    auto img1 = std::make_unique<Image>(800, 600);
    auto img2 = std::make_unique<Image>(1024, 768);

    std::cout << "Processing images..." << std::endl;
    // Automatic cleanup when exiting scope, exception-safe
}

// Container of Smart Pointers (very common pattern)
std::vector<std::unique_ptr<Image>> loadImageLibrary() {
    std::vector<std::unique_ptr<Image>> images;

    for (int i = 0; i < 3; ++i) {
        images.push_back(std::make_unique<Image>(640 + i*64, 480 + i*64));
    }

    return images;  // Move semantics transfers ownership to caller
}

int main() {
    std::cout << "--- Migration from Raw to Smart Pointers ---" << std::endl;
    processImagesNew();

    std::cout << "\nLoading image library:" << std::endl;
    auto library = loadImageLibrary();
    std::cout << "Library has " << library.size() << " images" << std::endl;

    return 0;
}

9. Custom Deleters & Complex Ownership Patterns

Đôi khi, bạn cần sử dụng các hàm hủy tùy chỉnh không chỉ cho `unique_ptr` mà cả cho `shared_ptr`. Ví dụ điển hình là quản lý `FILE*` hoặc các tiến trình (subprocess) được mở bằng `popen()`:

#include <iostream>
#include <memory>
#include <cstdio>

// Deleter for FILE*
struct FileCloser {
    void operator()(FILE* f) const {
        if (f) {
            std::cout << "[FileCloser] Closing file" << std::endl;
            fclose(f);
        }
    }
};

// Deleter for popen() subprocess
struct ProcessCloser {
    void operator()(FILE* p) const {
        if (p) {
            std::cout << "[ProcessCloser] Closing subprocess" << std::endl;
            pclose(p);
        }
    }
};

// File I/O with shared_ptr
void demonstrateFileHandling() {
    std::cout << "--- File Handling with Custom Deleter ---" << std::endl;

    // Using shared_ptr with custom deleter
    std::shared_ptr<FILE> file(
        fopen("/tmp/test.txt", "w"),
        FileCloser()
    );

    if (file) {
        fprintf(file.get(), "Hello from smart pointer!\n");
        std::cout << "File written successfully" << std::endl;
    }
    // FileCloser called automatically when shared_ptr is destroyed
}

// Subprocess handling
void demonstrateProcessHandling() {
    std::cout << "\n--- Subprocess Handling with Custom Deleter ---" << std::endl;

    std::shared_ptr<FILE> proc(
        popen("echo 'Running subprocess'", "r"),
        ProcessCloser()
    );

    if (proc) {
        char buffer[128];
        while (fgets(buffer, sizeof(buffer), proc.get()) != nullptr) {
            std::cout << "[Output] " << buffer;
        }
    }
    // ProcessCloser called automatically
}

int main() {
    demonstrateFileHandling();
    demonstrateProcessHandling();
    return 0;
}

10. Comparison Table: unique_ptr vs shared_ptr vs weak_ptr