Khi một chương trình C/C++ được biên dịch và chạy, bộ nhớ của nó được tổ chức thành nhiều vùng khác nhau. Mỗi vùng có mục đích, cách quản lý và vòng đời riêng. Hiểu rõ các vùng này là nền tảng quan trọng để viết mã an toàn, hiệu quả và tránh các lỗi như tràn bộ nhớ hay rò rỉ bộ nhớ. Bài viết này sẽ phân tích chi tiết từng vùng bộ nhớ, cách chúng hoạt động và sự khác biệt giữa chúng.

Tổng Quan Về Các Vùng Bộ Nhớ Chính

Một chương trình C/C++ điển hình sử dụng các vùng bộ nhớ sau:

• Vùng Stack (Ngăn xếp): Dùng cho biến cục bộ và lời gọi hàm. Do trình biên dịch tự động quản lý.
• Vùng Heap (Đống): Dùng cho cấp phát động (malloc, new). Lập trình viên phải tự giải phóng.
• Vùng Dữ liệu (Data Segment): Chứa biến toàn cục và biến tĩnh. Được chia làm hai phần: khởi tạo (RW) và chưa khởi tạo (BSS).
• Vùng Hằng số (Read-Only Data - .rodata): Chứa các hằng số và chuỗi ký tự. Chỉ đọc.
• Vùng Mã lệnh (Text/Code Segment - .text): Chứa mã máy của chương trình. Chỉ đọc và được chia sẻ giữa các tiến trình.

1. Vùng Stack (Ngăn xếp)

Stack là vùng nhớ được quản lý tự động bởi trình biên dịch. Nó hoạt động theo cơ chế LIFO (Last In, First Out). Các biến cục bộ, tham số hàm và địa chỉ trả về được lưu trữ tại đây. Khi một hàm được gọi, một khung ngăn xếp (stack frame) mới được tạo ra và khi hàm kết thúc, khung này tự động bị thu hồi.

• Đặc điểm: Tốc độ truy cập rất nhanh. Kích thước cố định và thường nhỏ (ví dụ: mặc định 1MB trên Visual C++). Dễ gây tràn stack nếu khai báo mảng lớn hoặc đệ quy quá sâu.
• Ví dụ:

  void functionA() {
      int x = 10;  // 'x' được lưu trên stack
      char buffer[256]; // 'buffer' cũng lưu trên stack
  } // Khi kết thúc hàm, 'x' và 'buffer' tự động bị xóa.

2. Vùng Heap (Đống)

Heap là vùng nhớ dùng cho cấp phát động. Kích thước của Heap có thể thay đổi trong quá trình chạy chương trình, phụ thuộc vào bộ nhớ khả dụng. Lập trình viên phải chủ động yêu cầu cấp phát (malloc, calloc, new) và giải phóng (free, delete).

• Đặc điểm: Kích thước lớn, linh hoạt. Tốc độ chậm hơn stack. Dễ gây rò rỉ bộ nhớ nếu không giải phóng. Có thể gây phân mảnh bộ nhớ.
• Ví dụ:

  int *ptr = (int*)malloc(sizeof(int) * 100); // Cấp phát 100 số nguyên trên heap
  if (ptr != NULL) {
      // Sử dụng vùng nhớ
      free(ptr); // Bắt buộc phải giải phóng
      ptr = NULL; // Tránh con trỏ treo
  }

3. Vùng Dữ Liệu Toàn Cục/Tĩnh (Data Segment & BSS)

Vùng này dành cho các biến toàn cục và biến tĩnh (static). Nó tồn tại trong suốt vòng đời của chương trình. Vùng này được chia làm hai phần nhỏ hơn:

• .data (Initialized Data Segment): Chứa các biến toàn cục và biến tĩnh đã được khởi tạo với giá trị khác 0.
• .bss (Block Started by Symbol - Uninitialized Data Segment): Chứa các biến toàn cục và biến tĩnh chưa được khởi tạo hoặc được khởi tạo bằng 0. Các biến này được hệ thống tự động gán giá trị 0 khi chương trình bắt đầu chạy. Điểm đặc biệt là vùng .bss không chiếm dung lượng trong file thực thi, chỉ chiếm bộ nhớ khi chạy.

int global_var = 5;   // Lưu trong .data
static int static_var; // Lưu trong .bss (chưa khởi tạo, mặc định = 0)
int global_zero = 0;  // Trình biên dịch tối ưu, đưa vào .bss

4. Vùng Hằng Số (.rodata - Read-Only Data)

Vùng này lưu trữ các dữ liệu hằng, không được phép thay đổi trong suốt quá trình chạy chương trình. Các chuỗi ký tự, hằng số được khai báo với từ khóa const thường được đặt ở đây. Cố gắng ghi vào vùng này sẽ gây ra lỗi segmentation fault.

• Ví dụ:

  const int MAX_VALUE = 100; // MAX_VALUE có thể được lưu trong .rodata
  char *str = "Hello";       // Chuỗi "Hello" nằm trong .rodata (không nên cố gắng sửa)

5. Vùng Mã Lệnh (.text - Code Segment)

Vùng này chứa các chỉ thị mã máy (machine instructions) của chương trình. Nó là vùng chỉ đọc (read-only) để ngăn chặn việc vô tình hoặc cố ý sửa đổi mã nguồn. Các tiến trình khác nhau chạy cùng một chương trình có thể chia sẻ chung một vùng .text để tiết kiệm bộ nhớ.

Ví dụ Minh Họa Phân Bổ Bộ Nhớ

Xét đoạn mã sau:

#include <stdlib.h>

int global_initialized = 10;               // .data
static int static_uninitialized;           // .bss
char *global_ptr;                         // .bss (con trỏ chưa khởi tạo)

int main() {
    int local_var = 5;                     // Stack
    char local_array[] = "world";         // "world" là hằng (.rodata), local_array là mảng sao chép trên stack
    char *heap_ptr = (char*)malloc(50);   // Cấp phát 50 byte trên Heap, heap_ptr nằm trên stack
    static int local_static = 0;           // .bss (biến tĩnh cục bộ)

    // Sử dụng bộ nhớ
    if (heap_ptr != NULL) {
        free(heap_ptr);
    }
    return 0;
}

• global_initialized (giá trị 10) được đặt trong vùng .data.
• static_uninitialized và global_ptr được đặt trong vùng .bss.
• local_var và con trỏ heap_ptr được lưu trên stack.
• Chuỗi hằng "world" được lưu trong vùng .rodata.
• 50 byte cấp phát bởi malloc nằm trên heap.

So Sánh Stack và Heap

Nắm vững cấu trúc bộ nhớ này giúp lập trình viên viết mã hiệu quả hơn, dễ dàng debug các lỗi liên quan đến bộ nhớ và tối ưu hóa hiệu năng chương trình.