Mở bài

Trong phần 1 của chuỗi bài “Tìm hiểu Pointer trong C”, chúng ta đã làm quen với các khái niệm cơ bản như cách khai báo con trỏ, sử dụng toán tử *, &, và hiểu cách bộ nhớ được tổ chức trong chương trình C. Tuy nhiên, đó mới chỉ là bước khởi đầu. Khi đi sâu hơn, bạn sẽ nhận ra rằng sức mạnh thực sự của con trỏ nằm ở khả năng quản lý bộ nhớ động và thao tác linh hoạt với mảng.

Trong lập trình C, mảng và con trỏ có mối liên hệ rất đặc biệt: mọi mảng đều có thể được coi như một con trỏ trỏ tới phần tử đầu tiên của nó. Nhờ đó, bạn có thể thao tác, truy cập, mở rộng, hoặc thu gọn mảng một cách tự do mà không cần phải biết trước kích thước.

Bên cạnh đó, các hàm cấp phát bộ nhớ động như malloc(), calloc(), realloc() và free() là công cụ quan trọng giúp lập trình viên chủ động quản lý vùng nhớ trên heap, thay vì phụ thuộc vào vùng nhớ tĩnh của stack. Việc hiểu rõ và sử dụng thành thạo các hàm này không chỉ giúp chương trình hoạt động hiệu quả hơn mà còn tránh được những lỗi nghiêm trọng như rò rỉ bộ nhớ (memory leak) hay tràn bộ nhớ (buffer overflow).

Bài viết này sẽ giúp bạn hiểu rõ:

• Mối quan hệ giữa mảng và con trỏ

• Cách sử dụng malloc, calloc, realloc, free một cách an toàn

• Ví dụ minh họa thực tế trong lập trình C

Mối quan hệ giữa mảng và con trỏ

Mảng và con trỏ có gì giống nhau?

Trong ngôn ngữ C, tên mảng thực chất là một con trỏ hằng trỏ đến phần tử đầu tiên của mảng. Điều này có nghĩa là khi bạn khai báo:

int arr[5] = {10, 20, 30, 40, 50};

thì arr tương đương với địa chỉ &arr[0].
Bạn có thể truy cập từng phần tử mảng thông qua phép toán con trỏ như sau:

printf("%d", *(arr + 2)); // In ra phần tử thứ 3: 30

Ví dụ minh họa

#include <stdio.h>

int main() {
    int arr[3] = {1, 2, 3};
    int *p = arr; // p trỏ đến phần tử đầu tiên của arr

    for (int i = 0; i < 3; i++) {
        printf("Phan tu %d = %d\n", i, *(p + i));
    }
    return 0;
}

Giải thích:

• p = arr nghĩa là p trỏ tới &arr[0]

• *(p + i) giúp truy cập phần tử thứ i của mảng.
  Điều này cho thấy mảng và con trỏ có thể dùng thay thế cho nhau trong nhiều trường hợp.

Lưu ý quan trọng

• Mảng không thể gán lại như con trỏ. Ví dụ:

  int arr[5];
  int *p;
  arr = p; // ❌ Sai! Tên mảng là hằng, không thể gán lại.
  

• Tuy nhiên, con trỏ có thể thay đổi địa chỉ mà nó trỏ tới, giúp thao tác linh hoạt hơn.

Cấp phát bộ nhớ động với malloc()

Cú pháp và nguyên lý hoạt động

void* malloc(size_t size);

Hàm malloc() cấp phát một vùng nhớ có kích thước size byte trên vùng heap và trả về con trỏ void* trỏ đến vùng nhớ đó.

Ví dụ:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    ptr = (int*) malloc(5 * sizeof(int)); // cấp phát vùng nhớ cho 5 số nguyên

    if (ptr == NULL) {
        printf("Khong du bo nho!\n");
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        ptr[i] = i + 1;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr[i]);
    }

    free(ptr); // giải phóng bộ nhớ
    return 0;
}

Giải thích

• malloc() cấp phát vùng nhớ nhưng không khởi tạo giá trị.

• Sau khi sử dụng, bạn phải gọi free() để trả lại vùng nhớ, tránh memory leak.

• sizeof(int) giúp đảm bảo tính tương thích giữa các hệ thống.

Cấp phát bộ nhớ với calloc()

Cú pháp

void* calloc(size_t n, size_t size);

Hàm calloc() cấp phát bộ nhớ cho n phần tử, mỗi phần tử có kích thước size byte, và tự động khởi tạo toàn bộ vùng nhớ về 0.

Ví dụ

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = (int*) calloc(5, sizeof(int));

    if (arr == NULL) {
        printf("Khong du bo nho!\n");
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]); // tất cả giá trị đều là 0
    }

    free(arr);
    return 0;
}

So sánh malloc và calloc

Thay đổi kích thước bộ nhớ với realloc()

Cú pháp

void* realloc(void* ptr, size_t new_size);

Hàm realloc() dùng để thay đổi kích thước vùng nhớ đã được cấp phát trước đó.

Ví dụ:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *p = (int*) malloc(2 * sizeof(int));
    p[0] = 10; p[1] = 20;

    p = (int*) realloc(p, 4 * sizeof(int)); // mở rộng vùng nhớ cho 4 phần tử
    p[2] = 30; p[3] = 40;

    for (int i = 0; i < 4; i++) {
        printf("%d ", p[i]);
    }

    free(p);
    return 0;
}

Lưu ý khi dùng realloc()

• Nếu không thể mở rộng vùng nhớ, realloc() trả về NULL nhưng vùng nhớ cũ vẫn giữ nguyên.

• Vì vậy, không nên gán trực tiếp mà nên gán vào biến tạm:

  int *temp = realloc(p, new_size);
  if (temp != NULL) p = temp;
  

• realloc() giúp tiết kiệm tài nguyên khi bạn cần thay đổi kích thước mảng động mà không mất dữ liệu cũ.

Giải phóng bộ nhớ với free()

Khi bạn dùng malloc(), calloc(), hoặc realloc(), vùng nhớ được cấp phát nằm trên heap và sẽ không tự động bị thu hồi khi kết thúc hàm. Vì vậy, bạn phải giải phóng nó thủ công bằng free().

Ví dụ

int *p = (int*) malloc(5 * sizeof(int));
free(p); // trả lại bộ nhớ cho hệ điều hành
p = NULL; // tránh lỗi dangling pointer

Các lỗi thường gặp

1. Không gọi free() → Memory leak

2. Gọi free() nhiều lần → Double free (lỗi nghiêm trọng)

3. Truy cập vùng nhớ sau khi đã free → Dangling pointer

👉 Mẹo tránh lỗi:

• Luôn gán con trỏ bằng NULL sau khi free().

• Sử dụng công cụ như Valgrind (Linux) để kiểm tra rò rỉ bộ nhớ.

Ứng dụng thực tế của pointer và cấp phát động

1. Xử lý mảng có kích thước thay đổi

Giả sử bạn không biết trước số lượng phần tử người dùng sẽ nhập, bạn có thể dùng malloc() hoặc realloc() để mở rộng mảng linh hoạt:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n, *arr;
    printf("Nhap so phan tu: ");
    scanf("%d", &n);

    arr = (int*) malloc(n * sizeof(int));

    for (int i = 0; i < n; i++) {
        printf("Nhap phan tu %d: ", i + 1);
        scanf("%d", &arr[i]);
    }

    printf("Mang vua nhap: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    free(arr);
    return 0;
}

2. Quản lý danh sách động (linked list)

Linked list là cấu trúc dữ liệu linh hoạt, được xây dựng hoàn toàn dựa trên con trỏ và cấp phát động. Đây là nền tảng cho nhiều cấu trúc phức tạp hơn như stack, queue, tree, graph.

Lời khuyên khi làm việc với bộ nhớ động

• Luôn kiểm tra giá trị trả về của malloc(), calloc(), realloc().

• Giải phóng bộ nhớ ngay khi không còn dùng.

• Tránh cấp phát quá lớn gây tràn bộ nhớ.

• Dùng calloc() khi cần khởi tạo dữ liệu mặc định là 0.

• Cẩn thận khi thay đổi kích thước mảng bằng realloc() để tránh mất dữ liệu.

Kết luận

Qua bài viết này, bạn đã hiểu rõ cách con trỏ làm việc với mảng và bộ nhớ động, cũng như cách sử dụng các hàm quan trọng: malloc(), calloc(), realloc() và free(). Đây là bước tiến lớn trong hành trình làm chủ lập trình C, giúp bạn không chỉ viết chương trình đúng mà còn viết chương trình tối ưu và an toàn.

Hãy nhớ rằng, pointer và quản lý bộ nhớ động là nền tảng cốt lõi để xây dựng các chương trình lớn, từ hệ điều hành, trình biên dịch cho đến các ứng dụng nhúng. Khi hiểu và thực hành nhuần nhuyễn, bạn sẽ tự tin hơn rất nhiều trong việc xử lý dữ liệu phức tạp, quản lý tài nguyên và nâng cao hiệu suất ứng dụng.

💡 Ở phần 3, chúng ta sẽ tiếp tục khám phá sâu hơn về pointer to pointer, mảng con trỏ, và con trỏ hàm (function pointer) – những kỹ thuật giúp bạn nâng tầm kỹ năng lập trình C lên một cấp độ hoàn toàn mới.
Hãy kiên trì học, thử nghiệm và bạn sẽ thấy “pointer” không còn đáng sợ — mà chính là vũ khí bí mật giúp bạn trở thành lập trình viên C chuyên nghiệp!