C++ Stack vs Heap Memory: Hiểu Sâu Về Bộ Nhớ

#include <iostream>
 
int globalVar = 42;                    // Data segment (đã khởi tạo)
int uninitializedGlobal;               // BSS segment (zero-initialized)
 
int main() {
    int stackVar = 10;                 // Stack
    static int staticLocal = 20;       // Data segment (đã khởi tạo)
    int* heapVar = new int(30);        // Pointer trên stack, value trên heap
 
    std::cout << "Stack:  " << &stackVar << '\n';
    std::cout << "Heap:   " << heapVar << '\n';
    std::cout << "Global: " << &globalVar << '\n';
    std::cout << "Static: " << &staticLocal << '\n';
 
    delete heapVar;
    return 0;
}

void bar(int y) {
    int local_b = y * 2;    // push lên stack
    // ... làm việc ...
}                            // local_b bị pop (destroyed)
 
void foo(int x) {
    int local_a = x + 1;    // push lên stack
    bar(local_a);            // frame mới push cho bar()
    // frame của bar đã pop khi tới đây
}                            // local_a bị pop (destroyed)
 
int main() {
    int n = 10;              // push lên stack
    foo(n);                  // frame mới push cho foo()
    return 0;                // n bị pop (destroyed)
}

#include <chrono>
#include <iostream>
 
void stackAllocation() {
    for (int i = 0; i < 1'000'000; i++) {
        int arr[100];           // Stack: chỉ dịch pointer
        arr[0] = i;             // Tránh optimization
    }
}
 
void heapAllocation() {
    for (int i = 0; i < 1'000'000; i++) {
        int* arr = new int[100]; // Heap: tìm block, update metadata
        arr[0] = i;
        delete[] arr;            // Heap: đánh dấu free, gộp block
    }
}
 
int main() {
    auto start = std::chrono::high_resolution_clock::now();
    stackAllocation();
    auto mid = std::chrono::high_resolution_clock::now();
    heapAllocation();
    auto end = std::chrono::high_resolution_clock::now();
 
    auto stackTime = std::chrono::duration_cast<std::chrono::microseconds>(mid - start);
    auto heapTime = std::chrono::duration_cast<std::chrono::microseconds>(end - mid);
 
    std::cout << "Stack: " << stackTime.count() << " μs\n";
    std::cout << "Heap:  " << heapTime.count() << " μs\n";
    std::cout << "Ratio: " << (double)heapTime.count() / stackTime.count() << "x slower\n";
 
    return 0;
}

void stackoverflow() {
    int hugeArray[1'000'000];  // 4 MB trên stack — có thể crash!
    hugeArray[0] = 42;
}

void process(int n) {
    // int arr[n];           // Variable-Length Arrays — KHÔNG phải standard C++!
    std::vector<int> arr(n); // Dùng heap qua std::vector thay thế
}

int* createValue() {
    int local = 42;
    return &local;  // DANGLING POINTER! local bị destroy khi return
}

// Nguyên nhân kinh điển: recursion không giới hạn
void infinite(int n) {
    int buffer[1000];        // Mỗi lần gọi tốn ~4 KB
    std::cout << n << '\n';
    infinite(n + 1);         // Không bao giờ dừng → stack overflow
}
 
// Fix: luôn có base case
void factorial(int n) {
    if (n <= 1) return;      // Base case dừng recursion
    factorial(n - 1);
}

#include <iostream>
 
int main() {
    // 1. Allocate: OS/allocator tìm block trống
    int* p = new int(42);
 
    // 2. Sử dụng: memory sống bao lâu tùy bạn
    std::cout << *p << '\n';
 
    // 3. Deallocate: bạn phải free thủ công
    delete p;
    p = nullptr;  // Good practice: tránh dangling pointer
 
    return 0;
}

#include <memory>
#include <string>
 
std::unique_ptr<std::string> createGreeting(const std::string& name) {
    // String này sống trên heap — tồn tại sau khi function return
    return std::make_unique<std::string>("Hello, " + name + "!");
}
 
int main() {
    auto greeting = createGreeting("World");
    std::cout << *greeting << '\n';  // "Hello, World!"
    // greeting tự động delete khi main() kết thúc
    return 0;
}

#include <vector>
 
void processLargeDataset() {
    // 100 triệu int = ~400 MB — quá lớn cho stack
    // std::vector allocate trên heap bên trong
    std::vector<int> data(100'000'000);
 
    for (int i = 0; i < data.size(); i++) {
        data[i] = i;
    }
    // destructor của vector free heap memory
}

#include <iostream>
#include <memory>
 
int main() {
    int n;
    std::cout << "Bao nhiêu phần tử? ";
    std::cin >> n;
 
    // Kích thước do user input quyết định — phải dùng heap
    auto arr = std::make_unique<int[]>(n);
 
    for (int i = 0; i < n; i++) {
        arr[i] = i * i;
    }
 
    return 0;
}

#include <iostream>
#include <vector>
 
// Minh họa fragmentation
int main() {
    std::vector<int*> ptrs;
 
    // Allocate nhiều block nhỏ
    for (int i = 0; i < 1000; i++) {
        ptrs.push_back(new int[10]);
    }
 
    // Free mỗi block thứ hai → tạo lỗ hổng
    for (int i = 0; i < 1000; i += 2) {
        delete[] ptrs[i];
        ptrs[i] = nullptr;
    }
 
    // Giờ thử allocate block lớn
    // Dù ~50% memory trống, nó có thể bị phân mảnh
    int* large = new int[5000];  // Có thể phải yêu cầu OS cấp memory mới
 
    // Cleanup
    for (int i = 1; i < 1000; i += 2) {
        delete[] ptrs[i];
    }
    delete[] large;
 
    return 0;
}

void example() {
    int x = 10;             // Tạo ở đây
    {
        int y = 20;          // Tạo ở đây
        std::string s = "hi"; // Tạo ở đây
    }                        // y và s bị destroy ở đây
 
    // y và s không tồn tại ở đây
}                            // x bị destroy ở đây

void example() {
    int* p = new int(42);    // Tạo trên heap
    // ...
    delete p;                // Destroy ở đây — BẠN quyết định khi nào
}
// Nếu quên delete → memory leak

int globalCounter = 0;       // Static: sống đến khi chương trình exit
 
void count() {
    static int calls = 0;   // Static local: khởi tạo một lần, tồn tại qua các lần gọi
    calls++;
    globalCounter++;
    std::cout << "Lần gọi #" << calls << ", global: " << globalCounter << '\n';
}
 
int main() {
    count();  // Lần gọi #1, global: 1
    count();  // Lần gọi #2, global: 2
    count();  // Lần gọi #3, global: 3
    return 0;
}

#include <iostream>
#include <thread>
 
thread_local int threadCounter = 0;  // Mỗi thread có bản copy riêng
 
void work(const std::string& name) {
    for (int i = 0; i < 3; i++) {
        threadCounter++;
        std::cout << name << ": " << threadCounter << '\n';
    }
}
 
int main() {
    std::thread t1(work, "Thread A");
    std::thread t2(work, "Thread B");
    t1.join();
    t2.join();
    // Mỗi thread đếm 1, 2, 3 độc lập
    return 0;
}

// ✅ Kiểu nhỏ, kích thước cố định
int count = 0;
double ratio = 3.14;
char grade = 'A';
 
// ✅ Struct và object nhỏ
struct Point { double x, y; };
Point origin{0.0, 0.0};
 
// ✅ std::array cho collection kích thước cố định
std::array<int, 10> scores{};
 
// ✅ Iterator và biến loop
for (auto it = vec.begin(); it != vec.end(); ++it) { /* ... */ }
 
// ✅ RAII lock guard
{
    std::lock_guard<std::mutex> lock(mtx);
    // ... critical section ...
}  // lock tự động release ở đây

// ✅ Collection với kích thước xác định lúc runtime
std::vector<int> data(n);          // heap bên trong
std::string name = getUserInput(); // heap bên trong
 
// ✅ Object lớn
auto matrix = std::make_unique<double[]>(1'000'000);
 
// ✅ Object sống lâu hơn scope
auto config = std::make_unique<Config>();
return config;  // ownership chuyển cho caller
 
// ✅ Object đa hình
std::unique_ptr<Shape> shape = std::make_unique<Circle>(5.0);
 
// ✅ Resource dùng chung
auto cache = std::make_shared<Cache>();
// Nhiều component giữ shared_ptr đến cùng cache

#include <fstream>
#include <memory>
#include <mutex>
 
void demonstrateRAII() {
    // 1. File handle: mở trong constructor, đóng trong destructor
    {
        std::ofstream file("output.txt");
        file << "Hello, RAII!\n";
    }  // file tự động đóng ở đây
 
    // 2. Smart pointer: memory free khi pointer ra khỏi scope
    {
        auto data = std::make_unique<int[]>(1000);
        data[0] = 42;
    }  // memory tự động free ở đây
 
    // 3. Lock guard: mutex unlock khi guard bị destroy
    std::mutex mtx;
    {
        std::lock_guard<std::mutex> lock(mtx);
        // ... critical section ...
    }  // mutex tự động unlock ở đây
}

#include <iostream>
#include <array>
 
struct Calculator {
    // Tất cả member trên stack
    std::array<double, 100> memory{};
    int top = 0;
 
    void push(double value) {
        if (top < 100) {
            memory[top++] = value;
        }
    }
 
    double pop() {
        if (top > 0) {
            return memory[--top];
        }
        return 0.0;
    }
 
    double add() {
        double b = pop(), a = pop();
        double result = a + b;
        push(result);
        return result;
    }
 
    double multiply() {
        double b = pop(), a = pop();
        double result = a * b;
        push(result);
        return result;
    }
};
 
int main() {
    Calculator calc;  // Toàn bộ calculator sống trên stack
    calc.push(3.0);
    calc.push(4.0);
    std::cout << "3 + 4 = " << calc.add() << '\n';      // 7
 
    calc.push(5.0);
    std::cout << "7 * 5 = " << calc.multiply() << '\n';  // 35
 
    return 0;
}

#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
class Graph {
    struct Node {
        std::string name;
        std::vector<Node*> neighbors;
 
        explicit Node(std::string n) : name(std::move(n)) {}
    };
 
    // Các node được sở hữu bởi graph, lưu trên heap
    std::unordered_map<std::string, std::unique_ptr<Node>> nodes;
 
public:
    void addNode(const std::string& name) {
        nodes[name] = std::make_unique<Node>(name);
    }
 
    void addEdge(const std::string& from, const std::string& to) {
        if (nodes.count(from) && nodes.count(to)) {
            nodes[from]->neighbors.push_back(nodes[to].get());
        }
    }
 
    void printNeighbors(const std::string& name) const {
        if (auto it = nodes.find(name); it != nodes.end()) {
            std::cout << name << " -> ";
            for (const auto* neighbor : it->second->neighbors) {
                std::cout << neighbor->name << " ";
            }
            std::cout << '\n';
        }
    }
};
 
int main() {
    Graph g;  // Graph object trên stack, node trên heap
 
    g.addNode("A");
    g.addNode("B");
    g.addNode("C");
    g.addEdge("A", "B");
    g.addEdge("A", "C");
    g.addEdge("B", "C");
 
    g.printNeighbors("A");  // A -> B C
    g.printNeighbors("B");  // B -> C
 
    return 0;
    // Tất cả node tự động free khi Graph destructor chạy
}

#include <chrono>
#include <iostream>
#include <memory>
#include <vector>
 
struct Particle {
    double x, y, z;
    double vx, vy, vz;
    double mass;
 
    void update(double dt) {
        x += vx * dt;
        y += vy * dt;
        z += vz * dt;
    }
};
 
// Strategy 1: Stack allocation với std::array
void simulateStack(int steps) {
    std::array<Particle, 1000> particles{};
    for (auto& p : particles) {
        p = {0.0, 0.0, 0.0, 1.0, 0.5, 0.2, 1.0};
    }
    for (int i = 0; i < steps; i++) {
        for (auto& p : particles) {
            p.update(0.01);
        }
    }
}
 
// Strategy 2: Heap allocation với std::vector
void simulateHeap(int steps) {
    std::vector<Particle> particles(1000);
    for (auto& p : particles) {
        p = {0.0, 0.0, 0.0, 1.0, 0.5, 0.2, 1.0};
    }
    for (int i = 0; i < steps; i++) {
        for (auto& p : particles) {
            p.update(0.01);
        }
    }
}
 
// Strategy 3: Heap với allocation riêng lẻ (worst case)
void simulateHeapScattered(int steps) {
    std::vector<std::unique_ptr<Particle>> particles;
    for (int i = 0; i < 1000; i++) {
        particles.push_back(std::make_unique<Particle>(
            Particle{0.0, 0.0, 0.0, 1.0, 0.5, 0.2, 1.0}
        ));
    }
    for (int i = 0; i < steps; i++) {
        for (auto& p : particles) {
            p->update(0.01);
        }
    }
}
 
int main() {
    const int steps = 10'000;
 
    auto measure = [](const std::string& name, auto func) {
        auto start = std::chrono::high_resolution_clock::now();
        func();
        auto end = std::chrono::high_resolution_clock::now();
        auto us = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        std::cout << name << ": " << us.count() << " μs\n";
    };
 
    measure("Stack (array)        ", [&]{ simulateStack(steps); });
    measure("Heap (vector)        ", [&]{ simulateHeap(steps); });
    measure("Heap (scattered ptrs)", [&]{ simulateHeapScattered(steps); });
 
    return 0;
}

// ❌ SAI: dangling pointer
int* bad() {
    int x = 42;
    return &x;     // x bị destroy khi bad() return
}
 
// ✅ ĐÚNG: return by value (move semantics làm cho efficient)
int good() {
    int x = 42;
    return x;      // Copy/move — an toàn
}
 
// ✅ ĐÚNG: return smart pointer đến heap object
std::unique_ptr<int> alsoGood() {
    return std::make_unique<int>(42);  // Heap object, ownership được transfer
}

// ❌ NGUY HIỂM: 40 MB trên stack
void bad() {
    double matrix[10'000'000];
}
 
// ✅ AN TOÀN: dùng std::vector (heap-backed)
void good() {
    std::vector<double> matrix(10'000'000);
}

// ❌ LEAK: exception trước delete
void bad() {
    int* data = new int[1000];
    riskyOperation();     // Nếu throw, delete[] không bao giờ chạy
    delete[] data;
}
 
// ✅ AN TOÀN: smart pointer handle cleanup kể cả khi exception
void good() {
    auto data = std::make_unique<int[]>(1000);
    riskyOperation();     // Kể cả nếu throw, memory vẫn được free
}

// ❌ CHẬM: hàng nghìn tiny heap allocation
std::vector<std::unique_ptr<int>> bad;
for (int i = 0; i < 10'000; i++) {
    bad.push_back(std::make_unique<int>(i));
}
 
// ✅ TỐT HƠN: một allocation liên tục duy nhất
std::vector<int> good(10'000);
for (int i = 0; i < 10'000; i++) {
    good[i] = i;
}

#include <cstddef>
#include <iostream>
#include <vector>
 
class Arena {
    std::vector<std::byte> buffer;
    std::size_t offset = 0;
 
public:
    explicit Arena(std::size_t size) : buffer(size) {}
 
    void* allocate(std::size_t size, std::size_t alignment = alignof(std::max_align_t)) {
        // Align offset
        std::size_t aligned = (offset + alignment - 1) & ~(alignment - 1);
 
        if (aligned + size > buffer.size()) {
            throw std::bad_alloc();
        }
 
        void* ptr = buffer.data() + aligned;
        offset = aligned + size;
        return ptr;
    }
 
    void reset() { offset = 0; }  // "Free" mọi thứ cùng lúc
 
    std::size_t used() const { return offset; }
    std::size_t capacity() const { return buffer.size(); }
};
 
int main() {
    Arena arena(1024);  // Arena 1 KB
 
    // Allocate từ arena — cực nhanh (chỉ dịch pointer)
    int* a = static_cast<int*>(arena.allocate(sizeof(int)));
    int* b = static_cast<int*>(arena.allocate(sizeof(int)));
    double* c = static_cast<double*>(arena.allocate(sizeof(double)));
 
    *a = 10;
    *b = 20;
    *c = 3.14;
 
    std::cout << *a << ", " << *b << ", " << *c << '\n';  // 10, 20, 3.14
    std::cout << "Used: " << arena.used() << " / " << arena.capacity() << " bytes\n";
 
    arena.reset();  // Mọi allocation free cùng lúc — O(1)
    std::cout << "Sau reset: " << arena.used() << " bytes used\n";
 
    return 0;
}

#include <iostream>
#include <memory_resource>
#include <vector>
 
int main() {
    // Stack-based buffer với monotonic allocator
    std::array<std::byte, 4096> buffer;
    std::pmr::monotonic_buffer_resource pool(buffer.data(), buffer.size());
 
    // Vector allocate từ pool thay vì global heap
    std::pmr::vector<int> vec(&pool);
 
    for (int i = 0; i < 100; i++) {
        vec.push_back(i);
    }
 
    std::cout << "Vector size: " << vec.size() << '\n';
    std::cout << "Allocate từ stack-backed pool — zero heap allocation!\n";
 
    return 0;
}