Deep Dive: Quản Lý Bộ Nhớ & Smart Pointers

#include <memory>
 
void example() {
    // Stack: cấp phát nhanh, tự dọn dẹp
    int x = 42;                    // hủy khi hết scope
    double arr[100];               // kích thước cố định, trên stack
 
    // Heap: kích thước linh hoạt, phải quản lý lifetime
    int* p = new int(42);          // BẠN phải delete cái này
    delete p;                      // dọn dẹp thủ công — dễ lỗi
 
    // Heap với smart pointer: tự dọn dẹp
    auto sp = std::make_unique<int>(42);  // tự delete
}   // x, arr, sp đều được dọn ở đây. Nếu quên 'delete p' → leak.

// KHÔNG CÓ RAII — quản lý resource thủ công
void processFile(const std::string& path) {
    FILE* f = fopen(path.c_str(), "r");
    if (!f) return;
 
    char* buffer = new char[1024];
 
    // Nếu hàm này throw thì sao?
    processData(f, buffer);
 
    delete[] buffer;    // bị skip nếu exception!
    fclose(f);          // bị skip nếu exception!
}

#include <fstream>
#include <vector>
#include <string>
 
// CÓ RAII — quản lý resource tự động
void processFile(const std::string& path) {
    std::ifstream file(path);       // mở file trong constructor
    if (!file) return;
 
    std::vector<char> buffer(1024); // cấp phát trong constructor
 
    processData(file, buffer);
 
}   // file đóng, buffer giải phóng — TỰ ĐỘNG
    // Kể cả khi processData throw — destructors LUÔN chạy

#include <cstdio>
#include <stdexcept>
#include <string>
 
class FileHandle {
public:
    explicit FileHandle(const std::string& path, const char* mode)
        : file_(fopen(path.c_str(), mode))
    {
        if (!file_) {
            throw std::runtime_error("Không mở được: " + path);
        }
    }
 
    // Destructor — luôn chạy khi object ra khỏi scope
    ~FileHandle() {
        if (file_) {
            fclose(file_);
        }
    }
 
    // Xóa copy operations — file handles không copy được
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
 
    // Cho phép move operations — chuyển ownership
    FileHandle(FileHandle&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }
 
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (file_) fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }
 
    FILE* get() const { return file_; }
 
    void write(const std::string& data) {
        fwrite(data.c_str(), 1, data.size(), file_);
    }
 
private:
    FILE* file_;
};
 
// Sử dụng
void writeReport() {
    FileHandle report("report.txt", "w");
    report.write("Hello, RAII!\n");
}   // file tự động đóng ở đây

#include <mutex>
#include <iostream>
 
// Mutex locking
std::mutex mtx;
 
void safeOperation() {
    std::lock_guard<std::mutex> lock(mtx);  // lock mutex
    // ... critical section ...
}   // mutex tự động unlock
 
// Database transactions
class Transaction {
public:
    explicit Transaction(Database& db) : db_(db) {
        db_.begin();
    }
    ~Transaction() {
        if (!committed_) {
            db_.rollback();   // tự rollback nếu chưa commit
        }
    }
    void commit() {
        db_.commit();
        committed_ = true;
    }
private:
    Database& db_;
    bool committed_ = false;
};

#include <memory>
#include <iostream>
#include <string>
 
struct User {
    std::string name;
    int age;
 
    User(std::string n, int a) : name(std::move(n)), age(a) {
        std::cout << "User created: " << name << "\n";
    }
    ~User() {
        std::cout << "User destroyed: " << name << "\n";
    }
};
 
int main() {
    // Tạo với make_unique (ưu tiên — exception-safe)
    auto alice = std::make_unique<User>("Alice", 30);
 
    std::cout << alice->name << " is " << alice->age << "\n";
 
    // Truy cập raw pointer (không chuyển ownership)
    User* raw = alice.get();
    std::cout << raw->name << "\n";
 
    // Kiểm tra có sở hữu gì không
    if (alice) {
        std::cout << "alice is not null\n";
    }
 
}   // alice bị hủy ở đây → User destroyed: Alice

#include <memory>
#include <iostream>
#include <vector>
 
auto createUser(std::string name, int age) {
    return std::make_unique<User>(std::move(name), age);
}
 
int main() {
    auto user = createUser("Bob", 25);
 
    // Chuyển ownership
    auto user2 = std::move(user);
 
    // user giờ là nullptr!
    if (!user) {
        std::cout << "user is null after move\n";
    }
 
    // Lưu trong containers
    std::vector<std::unique_ptr<User>> users;
    users.push_back(std::make_unique<User>("Charlie", 35));
    users.push_back(std::move(user2));
 
}   // tất cả users bị hủy khi vector bị hủy

#include <memory>
#include <iostream>
#include <vector>
#include <string>
 
class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual std::string name() const = 0;
};
 
class Circle : public Shape {
public:
    explicit Circle(double r) : radius_(r) {}
    double area() const override { return 3.14159 * radius_ * radius_; }
    std::string name() const override { return "Circle"; }
private:
    double radius_;
};
 
class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : width_(w), height_(h) {}
    double area() const override { return width_ * height_; }
    std::string name() const override { return "Rectangle"; }
private:
    double width_, height_;
};
 
int main() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(5.0));
    shapes.push_back(std::make_unique<Rectangle>(3.0, 4.0));
 
    for (const auto& shape : shapes) {
        std::cout << shape->name() << ": area = "
                  << shape->area() << "\n";
    }
}

#include <memory>
#include <iostream>
 
int main() {
    // Phiên bản array — tự gọi delete[]
    auto arr = std::make_unique<int[]>(100);
 
    for (int i = 0; i < 100; ++i) {
        arr[i] = i * i;
    }
 
    std::cout << "arr[10] = " << arr[10] << "\n"; // 100
}
 
// Nhưng hầu hết trường hợp nên dùng std::vector:
// std::vector<int> arr(100);

#include <memory>
#include <cstdio>
#include <iostream>
 
// Custom deleter cho FILE*
struct FileDeleter {
    void operator()(FILE* f) const {
        if (f) {
            std::cout << "Đang đóng file\n";
            fclose(f);
        }
    }
};
 
// Type bao gồm cả deleter
using FilePtr = std::unique_ptr<FILE, FileDeleter>;
 
FilePtr openFile(const char* path, const char* mode) {
    return FilePtr(fopen(path, mode));
}
 
int main() {
    auto file = openFile("data.txt", "w");
    if (file) {
        fprintf(file.get(), "Hello from unique_ptr!\n");
    }
}   // file được đóng bởi FileDeleter
 
// Lambda deleter (ngắn gọn hơn)
auto closerLambda = [](FILE* f) {
    if (f) fclose(f);
};
 
// Lưu ý: lambda deleters thay đổi unique_ptr type
std::unique_ptr<FILE, decltype(closerLambda)> file2(
    fopen("data.txt", "r"), closerLambda
);

#include <memory>
#include <iostream>
#include <string>
 
struct Config {
    std::string database_url;
    int max_connections;
 
    Config(std::string url, int max)
        : database_url(std::move(url)), max_connections(max) {}
    ~Config() { std::cout << "Config destroyed\n"; }
};
 
int main() {
    // Tạo với make_shared (single allocation, cache-friendly)
    auto config = std::make_shared<Config>("postgres://localhost/db", 10);
 
    std::cout << "ref count: " << config.use_count() << "\n"; // 1
 
    {
        // Copy — tăng reference count
        auto config2 = config;
        std::cout << "ref count: " << config.use_count() << "\n"; // 2
 
        auto config3 = config;
        std::cout << "ref count: " << config.use_count() << "\n"; // 3
 
    }   // config2, config3 bị hủy → ref count trở về 1
 
    std::cout << "ref count: " << config.use_count() << "\n"; // 1
 
}   // config bị hủy → ref count 0 → Config destroyed

#include <memory>
 
struct Widget {
    int x, y;
};
 
// TỐT: single allocation (object + control block cùng nhau)
auto w1 = std::make_shared<Widget>();
 
// KÉM HƠN: hai allocations (object + control block riêng)
std::shared_ptr<Widget> w2(new Widget());
 
// NGUY HIỂM: có thể leak trong function arguments trước C++17
// process(std::shared_ptr<Widget>(new Widget()), mightThrow());
// Nếu mightThrow() throw sau new nhưng trước shared_ptr constructor,
// Widget bị leak. make_shared tránh hoàn toàn vấn đề này.

#include <memory>
#include <iostream>
#include <string>
#include <vector>
 
class Logger {
public:
    void log(const std::string& msg) {
        std::cout << "[LOG] " << msg << "\n";
    }
};
 
class Service {
public:
    explicit Service(std::string name, std::shared_ptr<Logger> logger)
        : name_(std::move(name)), logger_(std::move(logger)) {}
 
    void doWork() {
        logger_->log(name_ + " doing work");
    }
 
private:
    std::string name_;
    std::shared_ptr<Logger> logger_;  // shared ownership
};
 
int main() {
    auto logger = std::make_shared<Logger>();
 
    // Nhiều services chia sẻ cùng một logger
    Service auth("AuthService", logger);
    Service data("DataService", logger);
    Service cache("CacheService", logger);
 
    std::cout << "Logger ref count: " << logger.use_count() << "\n"; // 4
 
    auth.doWork();
    data.doWork();
    cache.doWork();
}
// Logger chỉ bị hủy sau khi TẤT CẢ services và 'logger' biến mất

#include <memory>
#include <iostream>
#include <string>
 
struct Pair {
    std::string first;
    std::string second;
};
 
int main() {
    auto pair = std::make_shared<Pair>(Pair{"hello", "world"});
 
    // Aliasing constructor: chia sẻ ownership của 'pair',
    // nhưng trỏ đến pair->first
    std::shared_ptr<std::string> first(pair, &pair->first);
 
    pair.reset();  // release handle của chúng ta
 
    // 'first' giữ cả Pair sống!
    std::cout << *first << "\n"; // "hello" — vẫn valid!
    std::cout << "ref count: " << first.use_count() << "\n"; // 1
}

// Chi phí cụ thể:
// 1. Allocation thêm cho control block (tránh được với make_shared)
// 2. Atomic reference count increment/decrement (thread-safe nhưng ~10-50ns)
// 3. Hai pointers mỗi shared_ptr (16 bytes trên 64-bit vs 8 cho raw/unique)
// 4. Control block lưu: strong count, weak count, deleter, allocator
 
// Khi nào nó quan trọng:
// - Tight loops với hàng triệu copies → overhead đo được
// - Single-threaded code → atomic ops là overhead không cần thiết
// - Collections lớn → 2x pointer storage cộng dồn

#include <memory>
#include <iostream>
#include <string>
 
struct Node {
    std::string name;
    std::shared_ptr<Node> next;  // sở hữu node tiếp theo
    std::shared_ptr<Node> prev;  // VẤN ĐỀ: circular ownership!
 
    Node(std::string n) : name(std::move(n)) {
        std::cout << "Node " << name << " created\n";
    }
    ~Node() {
        std::cout << "Node " << name << " destroyed\n";
    }
};
 
int main() {
    auto a = std::make_shared<Node>("A");
    auto b = std::make_shared<Node>("B");
 
    a->next = b;   // A sở hữu B
    b->prev = a;   // B sở hữu A → CIRCULAR REFERENCE!
 
    std::cout << "a ref count: " << a.use_count() << "\n"; // 2
    std::cout << "b ref count: " << b.use_count() << "\n"; // 2
}
// a ra khỏi scope → ref count giảm xuống 1 (b->prev vẫn giữ)
// b ra khỏi scope → ref count giảm xuống 1 (a->next vẫn giữ)
// KHÔNG CÁI NÀO bị hủy! MEMORY LEAK!

#include <memory>
#include <iostream>
#include <string>
 
struct Node {
    std::string name;
    std::shared_ptr<Node> next;   // sở hữu node tiếp theo
    std::weak_ptr<Node> prev;     // SỬA: non-owning back-reference
 
    Node(std::string n) : name(std::move(n)) {
        std::cout << "Node " << name << " created\n";
    }
    ~Node() {
        std::cout << "Node " << name << " destroyed\n";
    }
};
 
int main() {
    auto a = std::make_shared<Node>("A");
    auto b = std::make_shared<Node>("B");
 
    a->next = b;   // A sở hữu B
    b->prev = a;   // weak reference — không ảnh hưởng ref count
 
    std::cout << "a ref count: " << a.use_count() << "\n"; // 1
    std::cout << "b ref count: " << b.use_count() << "\n"; // 2
 
    // Truy cập qua weak_ptr — phải lock trước
    if (auto prev = b->prev.lock()) {
        std::cout << "B's prev: " << prev->name << "\n";
    }
}
// a bị hủy → a ref count 0 → Node A destroyed
// → a->next (shared_ptr đến B) bị hủy → b ref count giảm xuống 1
// b bị hủy → b ref count 0 → Node B destroyed
// Không leak!

#include <memory>
#include <iostream>
 
void useWeakPtr(std::weak_ptr<int> weak) {
    // Cách 1: lock() — trả về shared_ptr hoặc nullptr
    if (auto shared = weak.lock()) {
        std::cout << "Value: " << *shared << "\n";
    } else {
        std::cout << "Object đã bị hủy\n";
    }
 
    // Cách 2: expired() — kiểm tra mà không lock
    if (weak.expired()) {
        std::cout << "Object đã mất\n";
    }
}
 
int main() {
    std::weak_ptr<int> weak;
 
    {
        auto shared = std::make_shared<int>(42);
        weak = shared;
 
        useWeakPtr(weak); // in "Value: 42"
    }   // shared bị hủy ở đây
 
    useWeakPtr(weak);     // in "Object đã bị hủy"
}

#include <memory>
#include <vector>
#include <algorithm>
#include <iostream>
#include <string>
 
class EventEmitter {
public:
    using Listener = std::shared_ptr<std::function<void(const std::string&)>>;
 
    void subscribe(Listener listener) {
        listeners_.push_back(listener);
    }
 
    void emit(const std::string& event) {
        // Dọn dẹp listeners hết hạn và notify các active
        listeners_.erase(
            std::remove_if(listeners_.begin(), listeners_.end(),
                [](const std::weak_ptr<std::function<void(const std::string&)>>& w) {
                    return w.expired();
                }),
            listeners_.end()
        );
 
        for (auto& weak : listeners_) {
            if (auto listener = weak.lock()) {
                (*listener)(event);
            }
        }
    }
 
private:
    std::vector<std::weak_ptr<std::function<void(const std::string&)>>> listeners_;
};

#include <memory>
#include <unordered_map>
#include <string>
#include <iostream>
 
class ImageCache {
public:
    std::shared_ptr<Image> load(const std::string& path) {
        // Kiểm tra image còn trong memory không
        auto it = cache_.find(path);
        if (it != cache_.end()) {
            if (auto img = it->second.lock()) {
                std::cout << "Cache hit: " << path << "\n";
                return img;  // vẫn sống — tái sử dụng
            }
            // hết hạn — xóa entry cũ
            cache_.erase(it);
        }
 
        // Load image mới
        std::cout << "Cache miss: " << path << "\n";
        auto img = std::make_shared<Image>(path);
        cache_[path] = img;  // lưu weak reference
        return img;
    }
 
private:
    std::unordered_map<std::string, std::weak_ptr<Image>> cache_;
};

#include <memory>
#include <string>
 
class Widget {
public:
    std::string name;
};
 
// 1. Nhận bằng raw pointer hoặc reference — "Tôi chỉ dùng, không sở hữu"
void inspect(const Widget& w) {
    // read-only access, caller giữ ownership
    std::cout << w.name << "\n";
}
 
void modify(Widget& w) {
    // read-write access, caller giữ ownership
    w.name = "modified";
}
 
// 2. Nhận unique_ptr bằng value — "Cho tôi ownership (sink parameter)"
void consume(std::unique_ptr<Widget> w) {
    // Tôi giờ sở hữu widget này. Nó bị hủy khi tôi xong.
    std::cout << "Consumed: " << w->name << "\n";
}
 
// 3. Nhận unique_ptr bằng reference — "Tôi có thể lấy ownership"
void maybeConsume(std::unique_ptr<Widget>& w) {
    if (w->name == "disposable") {
        w.reset();  // lấy và hủy
    }
}
 
// 4. Nhận shared_ptr bằng value — "Tôi cần shared ownership"
void share(std::shared_ptr<Widget> w) {
    // Tôi giờ đồng sở hữu widget này
    // (ref count tăng khi gọi, giảm khi function return)
}
 
// 5. Nhận shared_ptr bằng const ref — "Tôi có thể share ownership"
void maybeShare(const std::shared_ptr<Widget>& w) {
    // Rẻ khi gọi — không thay đổi ref count
    // Có thể copy nếu quyết định giữ lại
}

#include <memory>
#include <string>
 
// Factory — return unique_ptr (caller nhận ownership)
std::unique_ptr<Widget> createWidget(std::string name) {
    auto w = std::make_unique<Widget>();
    w->name = std::move(name);
    return w;  // tự động move (NRVO hoặc implicit move)
}
 
// Shared factory — khi callers sẽ share kết quả
std::shared_ptr<Widget> getSharedWidget() {
    static auto instance = std::make_shared<Widget>();
    return instance;
}

#include <memory>
#include <string>
#include <vector>
 
class Engine {
public:
    void run() { /* ... */ }
};
 
class Car {
public:
    // Exclusive ownership — Car sở hữu Engine
    Car() : engine_(std::make_unique<Engine>()) {}
 
    // Cung cấp non-owning access
    Engine& engine() { return *engine_; }
 
private:
    std::unique_ptr<Engine> engine_;
};
 
class Team {
public:
    void addMember(std::shared_ptr<Player> player) {
        members_.push_back(std::move(player));
    }
 
private:
    // Shared ownership — players có thể ở nhiều teams
    std::vector<std::shared_ptr<Player>> members_;
};

#include <memory>
#include <iostream>
 
// BUG: return reference đến local object
int& dangling() {
    int x = 42;
    return x;  // x bị hủy khi hết scope!
}
 
// BUG: giữ raw pointer sau khi unique_ptr bị move
void danglingFromMove() {
    auto ptr = std::make_unique<int>(42);
    int* raw = ptr.get();
 
    auto ptr2 = std::move(ptr);  // ownership đã chuyển
 
    // raw giờ DANGLING — ptr không còn sở hữu object
    // *raw là undefined behavior!
}
 
// SỬA: không sống lâu hơn owner
void safe() {
    auto ptr = std::make_unique<int>(42);
    int* raw = ptr.get();
 
    // Chỉ dùng raw khi ptr còn sống và chưa move
    std::cout << *raw << "\n"; // OK
 
    // Không move ptr khi raw đang được dùng
}

#include <memory>
 
// BUG: hai shared_ptrs từ cùng raw pointer
void doubleFree() {
    int* raw = new int(42);
 
    std::shared_ptr<int> sp1(raw);
    std::shared_ptr<int> sp2(raw);  // NGUY HIỂM: control blocks riêng!
 
    // Khi sp1 bị hủy → delete raw
    // Khi sp2 bị hủy → delete raw LẦN NỮA → crash!
}
 
// SỬA: luôn dùng make_shared, hoặc tạo từ shared_ptr có sẵn
void safe() {
    auto sp1 = std::make_shared<int>(42);
    auto sp2 = sp1;  // cùng control block, ref count = 2
}

#include <memory>
 
struct Parent;
struct Child;
 
struct Parent {
    std::shared_ptr<Child> child;
    ~Parent() { std::cout << "Parent destroyed\n"; }
};
 
struct Child {
    std::shared_ptr<Parent> parent;  // BUG: circular!
    ~Child() { std::cout << "Child destroyed\n"; }
};
 
// SỬA: dùng weak_ptr cho back-reference
struct ChildFixed {
    std::weak_ptr<Parent> parent;    // non-owning
    ~ChildFixed() { std::cout << "ChildFixed destroyed\n"; }
};

#include <memory>
#include <vector>
#include <iostream>
 
// BUG: tạo shared_ptr từ raw 'this'
class BadWidget {
public:
    void addToList(std::vector<std::shared_ptr<BadWidget>>& list) {
        // NGUY HIỂM: tạo control block mới từ raw pointer!
        list.push_back(std::shared_ptr<BadWidget>(this));
    }
};
 
// SỬA: kế thừa từ enable_shared_from_this
class GoodWidget : public std::enable_shared_from_this<GoodWidget> {
public:
    void addToList(std::vector<std::shared_ptr<GoodWidget>>& list) {
        // An toàn: dùng control block có sẵn
        list.push_back(shared_from_this());
    }
};
 
// Sử dụng — PHẢI được quản lý bởi shared_ptr trước
auto widget = std::make_shared<GoodWidget>();
std::vector<std::shared_ptr<GoodWidget>> list;
widget->addToList(list);  // an toàn!

#include <memory>
#include <iostream>
 
class Base {
public:
    virtual ~Base() = default;
    virtual void speak() { std::cout << "Base\n"; }
};
 
class Derived : public Base {
public:
    void speak() override { std::cout << "Derived\n"; }
    int extra_data = 42;
};
 
// OK: smart pointers đến base class hoạt động đúng
std::unique_ptr<Base> ptr = std::make_unique<Derived>();
ptr->speak();  // in "Derived" — polymorphism hoạt động!
 
// BUG: value-type slicing (không phải lỗi smart pointer, nhưng hay nhầm)
Base base = Derived();  // SLICED! extra_data mất, speak() gọi Base::speak

// widget.h — public header
#pragma once
#include <memory>
#include <string>
 
class Widget {
public:
    Widget(std::string name);
    ~Widget();  // phải khai báo trong header, define trong .cpp
 
    // Move operations
    Widget(Widget&&) noexcept;
    Widget& operator=(Widget&&) noexcept;
 
    // Không copy
    Widget(const Widget&) = delete;
    Widget& operator=(const Widget&) = delete;
 
    void doSomething();
    std::string name() const;
 
private:
    struct Impl;                  // forward declaration
    std::unique_ptr<Impl> pimpl_; // pointer đến implementation
};

// widget.cpp — implementation (có thể thay đổi mà không recompile users)
#include "widget.h"
#include <iostream>
#include <vector>
 
struct Widget::Impl {
    std::string name;
    std::vector<int> data;
    // ... bất kỳ private members nào, kể cả heavy headers
};
 
Widget::Widget(std::string name)
    : pimpl_(std::make_unique<Impl>()) {
    pimpl_->name = std::move(name);
}
 
Widget::~Widget() = default;  // phải ở .cpp nơi Impl là complete type
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
 
void Widget::doSomething() {
    pimpl_->data.push_back(42);
    std::cout << pimpl_->name << " did something\n";
}
 
std::string Widget::name() const {
    return pimpl_->name;
}

#include <memory>
#include <vector>
#include <iostream>
#include <functional>
 
template<typename T>
class ObjectPool {
public:
    using Deleter = std::function<void(T*)>;
    using Ptr = std::unique_ptr<T, Deleter>;
 
    explicit ObjectPool(size_t initial_size = 10) {
        for (size_t i = 0; i < initial_size; ++i) {
            pool_.push_back(std::make_unique<T>());
        }
    }
 
    Ptr acquire() {
        if (pool_.empty()) {
            // Pool cạn — tạo object mới
            return Ptr(new T(), [this](T* obj) {
                pool_.push_back(std::unique_ptr<T>(obj));
            });
        }
 
        // Lấy từ pool — return với custom deleter để recycle
        auto obj = pool_.back().release();
        pool_.pop_back();
 
        return Ptr(obj, [this](T* obj) {
            pool_.push_back(std::unique_ptr<T>(obj));
        });
    }
 
    size_t available() const { return pool_.size(); }
 
private:
    std::vector<std::unique_ptr<T>> pool_;
};
 
// Sử dụng
struct Connection {
    void reset() { /* reset state để tái sử dụng */ }
};
 
int main() {
    ObjectPool<Connection> pool(5);
    std::cout << "Available: " << pool.available() << "\n"; // 5
 
    {
        auto conn1 = pool.acquire();
        auto conn2 = pool.acquire();
        std::cout << "Available: " << pool.available() << "\n"; // 3
    }   // conn1, conn2 trả về pool
 
    std::cout << "Available: " << pool.available() << "\n"; // 5
}

#include <memory_resource>
#include <vector>
#include <iostream>
 
int main() {
    // Buffer trên stack — hoàn toàn không heap allocation
    char buffer[4096];
    std::pmr::monotonic_buffer_resource pool(buffer, sizeof(buffer));
 
    // Vector allocate từ buffer của chúng ta
    std::pmr::vector<int> vec(&pool);
    for (int i = 0; i < 100; ++i) {
        vec.push_back(i);
    }
 
    std::cout << "Size: " << vec.size() << "\n";
    // Tất cả allocations đến từ 'buffer' — zero heap allocations!
}

#include <memory>
#include <cstdlib>
#include <iostream>
 
// Custom deleter cho aligned memory
struct AlignedDeleter {
    void operator()(void* ptr) const {
        std::free(ptr);
    }
};
 
// Allocate aligned memory với smart pointer
auto makeAligned(size_t alignment, size_t size) {
    void* ptr = std::aligned_alloc(alignment, size);
    return std::unique_ptr<void, AlignedDeleter>(ptr);
}
 
int main() {
    // 64-byte aligned buffer (cache line aligned)
    auto buffer = makeAligned(64, 1024);
    std::cout << "Aligned: "
              << (reinterpret_cast<uintptr_t>(buffer.get()) % 64 == 0)
              << "\n"; // 1 (true)
}
 
// C++17: alignas trong classes
struct alignas(64) CacheAligned {
    int data[16];
};
 
auto ptr = std::make_unique<CacheAligned>();
// Lưu ý: make_unique tôn trọng alignas từ C++17

# Compile với ASan
g++ -fsanitize=address -g -O1 main.cpp -o main
clang++ -fsanitize=address -g -O1 main.cpp -o main
 
# Chạy — ASan báo lỗi với stack traces
./main

// Ví dụ: ASan bắt use-after-free
#include <memory>
 
int main() {
    auto ptr = std::make_unique<int>(42);
    int* raw = ptr.get();
    ptr.reset();       // giải phóng memory
    return *raw;       // ASan: "use-after-free"
}

# Chạy dưới Valgrind (chậm hơn nhưng kỹ hơn)
valgrind --leak-check=full --show-leak-kinds=all ./main

# Thường đi kèm ASan, hoặc standalone:
g++ -fsanitize=leak -g main.cpp -o main
./main

# Bật hết warnings
g++ -Wall -Wextra -Wpedantic -Werror -std=c++20 main.cpp
clang++ -Wall -Wextra -Wpedantic -Werror -std=c++20 main.cpp

// Bước 1: Wrap raw pointers có sẵn trong unique_ptr khi tạo
// TRƯỚC:
Widget* w = new Widget();
// ... 200 dòng sau ...
delete w;
 
// SAU:
auto w = std::make_unique<Widget>();
// ... 200 dòng sau ...
// (tự động cleanup)
 
// Bước 2: Thay raw pointer parameters bằng references
// TRƯỚC:
void process(Widget* w) { w->doThing(); }
// SAU:
void process(Widget& w) { w.doThing(); }
 
// Bước 3: Thay ownership transfers bằng unique_ptr
// TRƯỚC:
Widget* create() { return new Widget(); }  // caller phải delete
// SAU:
std::unique_ptr<Widget> create() { return std::make_unique<Widget>(); }

class Socket {
public:
    explicit Socket(int port);  // mở socket
    ~Socket();                  // đóng socket
 
    Socket(Socket&&) noexcept;
    Socket& operator=(Socket&&) noexcept;
 
    // Không copy
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;
 
    void send(const std::string& data);
    std::string receive();
 
private:
    int fd_ = -1;  // file descriptor
};

struct TreeNode {
    int value;
    std::vector<std::unique_ptr<TreeNode>> children;
    TreeNode* parent = nullptr;  // non-owning back reference
 
    void addChild(int val) {
        auto child = std::make_unique<TreeNode>();
        child->value = val;
        child->parent = this;
        children.push_back(std::move(child));
    }
};

class Button {
public:
    using Callback = std::function<void()>;
 
    void onClick(std::weak_ptr<Callback> cb) {
        callbacks_.push_back(cb);
    }
 
    void click() {
        // Xóa expired, gọi active
        // ... implement cái này
    }
 
private:
    std::vector<std::weak_ptr<Callback>> callbacks_;
};