Mở bài

Con trỏ (pointer) là một trong những khái niệm cốt lõi và khó nhất của ngôn ngữ lập trình C. Nhưng một khi bạn hiểu được cách dùng pointer trong function, bạn sẽ mở khóa sức mạnh thật sự của C: khả năng thao tác trực tiếp trên vùng nhớ, thay đổi biến gốc bên ngoài hàm, và xử lý dữ liệu linh hoạt, tiết kiệm tài nguyên.

Trong phần 3 của chuỗi bài “Tìm hiểu Pointer trong C”, chúng ta sẽ cùng tìm hiểu cách sử dụng con trỏ trong function — từ cơ chế truyền tham chiếu, cách hàm thay đổi biến bên ngoài, đến việc trả về con trỏ, làm việc với mảng động, hay thậm chí là “pointer to function” (con trỏ trỏ đến hàm).

Bài viết sẽ giúp bạn hiểu rõ cơ chế hoạt động của con trỏ trong hàm, tránh được các lỗi nguy hiểm như dangling pointer hay memory leak, đồng thời tự tin áp dụng chúng vào dự án thực tế.

Tại sao phải dùng pointer trong function?

Theo mặc định, khi bạn truyền biến vào hàm trong C, giá trị được truyền là một bản sao — vì vậy mọi thay đổi chỉ diễn ra trong phạm vi hàm và không ảnh hưởng đến biến gốc bên ngoài. Điều này được gọi là pass-by-value.

Nếu bạn muốn hàm có thể thay đổi trực tiếp biến gốc, hoặc muốn tiết kiệm bộ nhớ khi truyền các cấu trúc dữ liệu lớn, bạn phải truyền địa chỉ của biến, tức là sử dụng pointer.

Lợi ích khi dùng pointer trong function:

• Truyền tham chiếu (pass-by-reference): Cho phép hàm thay đổi giá trị thật sự của biến gốc.

• Giảm sao chép dữ liệu: Khi truyền mảng hoặc struct lớn, chỉ cần truyền địa chỉ, giúp tiết kiệm bộ nhớ và tăng tốc độ.

• Làm việc với mảng: Trong C, khi bạn truyền mảng vào hàm, thực chất bạn đang truyền con trỏ trỏ đến phần tử đầu tiên của mảng.

• Quản lý bộ nhớ động: Có thể cấp phát, mở rộng hoặc giải phóng bộ nhớ từ trong hàm.

• Tạo hàm linh hoạt: Con trỏ hàm cho phép truyền hành vi (hàm callback), giúp chương trình có khả năng mở rộng mạnh mẽ.

Truyền con trỏ vào hàm: Cơ chế pass-by-reference

Nguyên lý hoạt động

Khi bạn truyền con trỏ vào hàm, nghĩa là bạn đang truyền địa chỉ của biến gốc. Hàm nhận con trỏ và có thể thao tác trực tiếp lên vùng nhớ mà con trỏ đó trỏ tới.

Ví dụ minh họa:

void update(int *p) {
    *p = 42; // Thay đổi giá trị tại địa chỉ p
}

int main() {
    int x = 10;
    update(&x); // Truyền địa chỉ của x
    printf("%d", x); // Kết quả: 42
}

Ở đây, *p chính là giá trị tại địa chỉ mà p trỏ tới, nên khi thay đổi *p, bạn đang thay đổi trực tiếp x.

Ví dụ điển hình: Hàm hoán đổi hai số

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 8;
    swap(&x, &y);
    printf("x=%d, y=%d\n", x, y); // Kết quả: x=8, y=5
}

Lưu ý quan trọng

• Trước khi truy cập *p, luôn đảm bảo con trỏ không NULL.

• Có thể kiểm tra như sau:

  if (p != NULL) {
      *p = 100;
  }
  

• Không nên truyền con trỏ chưa được khởi tạo, vì sẽ gây lỗi “segmentation fault”.

Truyền mảng vào hàm: Mối quan hệ giữa pointer và array

Trong C, tên của mảng thực chất là địa chỉ phần tử đầu tiên. Khi truyền mảng vào hàm, bạn thực chất đang truyền một con trỏ, không phải toàn bộ mảng.

Ví dụ:

void increase_all(int arr[], int n) {
    for (int i = 0; i < n; ++i)
        arr[i]++;
}

int main() {
    int a[] = {1, 2, 3};
    increase_all(a, 3);
    // Kết quả: {2, 3, 4}
}

Trong ví dụ này, khi a được truyền vào hàm, nó hoạt động như int *arr. Vì vậy, mọi thay đổi trong hàm đều tác động trực tiếp đến mảng thật sự trong main().

Các cách khai báo tham số mảng

Các dạng dưới đây đều tương đương nhau khi truyền mảng:

void func(int arr[]);
void func(int *arr);
void func(int arr[10]);

Lưu ý

• Khi truyền mảng vào hàm, bạn phải truyền kèm kích thước vì hàm không thể tự biết độ dài mảng.

• Nếu không kiểm soát chỉ số, rất dễ truy cập ngoài vùng nhớ.

Trả về con trỏ từ hàm: Những nguyên tắc an toàn

Hàm trong C hoàn toàn có thể trả về một con trỏ, nhưng cần tuân thủ nguyên tắc an toàn về phạm vi sống của biến.

❌ Sai lầm phổ biến: Trả về địa chỉ của biến cục bộ

int* wrong_func() {
    int x = 10;
    return &x; // Sai, vì x bị hủy sau khi hàm kết thúc
}

Khi hàm wrong_func() kết thúc, biến x trên stack bị giải phóng. Con trỏ trả về sẽ trỏ đến vùng nhớ không còn hợp lệ.

✅ Cách đúng: Cấp phát động hoặc truyền con trỏ từ caller

1. Cấp phát trong hàm, trả về con trỏ:

   int* create_array(int n) {
       int *arr = malloc(n * sizeof(int));
       if (!arr) return NULL;
       for (int i = 0; i < n; i++) arr[i] = i + 1;
       return arr; // arr nằm trên heap, hợp lệ
   }
   
   int main() {
       int *a = create_array(5);
       free(a);
   }
   

2. Caller cấp phát và truyền con trỏ vào để hàm xử lý:

   void fill_array(int *arr, int n) {
       for (int i = 0; i < n; i++) arr[i] = i * 2;
   }
   
   int main() {
       int a[5];
       fill_array(a, 5);
   }
   

Lưu ý:

• Khi hàm cấp phát bộ nhớ bằng malloc, caller phải có trách nhiệm free().

• Luôn kiểm tra NULL khi nhận con trỏ trả về.

Cấp phát và mở rộng bộ nhớ trong function

Đây là tình huống thường gặp khi bạn muốn xử lý dữ liệu động trong hàm.

Ví dụ: Mở rộng mảng bằng realloc

int* append_value(int *arr, size_t *n, int value) {
    int *tmp = realloc(arr, (*n + 1) * sizeof(int));
    if (!tmp) return arr; // Giữ mảng cũ nếu realloc thất bại
    tmp[*n] = value;
    (*n)++;
    return tmp;
}

int main() {
    size_t n = 3;
    int *a = malloc(n * sizeof(int));
    a[0]=1; a[1]=2; a[2]=3;

    a = append_value(a, &n, 4);
    // Kết quả: a = {1, 2, 3, 4}

    free(a);
}

Nguyên tắc an toàn:

• Luôn dùng biến tạm (tmp) khi dùng realloc để tránh mất vùng nhớ nếu cấp phát thất bại.

• Khi tăng kích thước mảng, nhớ cập nhật biến đếm (*n).

• Không bao giờ realloc con trỏ đã free.

Pointer to Pointer: Khi cần hàm thay đổi chính con trỏ

Khi bạn muốn hàm gán một vùng nhớ mới cho con trỏ bên ngoài, bạn phải truyền con trỏ tới con trỏ (int **p).

Ví dụ:

int allocate(int **p, size_t n) {
    *p = malloc(n * sizeof(int));
    if (!*p) return -1;
    for (size_t i = 0; i < n; i++) (*p)[i] = i + 1;
    return 0;
}

int main() {
    int *a = NULL;
    if (allocate(&a, 5) == 0) {
        for (int i = 0; i < 5; i++) printf("%d ", a[i]);
        free(a);
    }
}

Ở đây:

• a là con trỏ trong main().

• allocate(&a, 5) truyền địa chỉ của a → hàm có thể gán vùng nhớ mới cho a.

• Dùng (*p)[i] để truy cập giá trị thực tế trong mảng.

Pointer to function: Truyền hàm vào hàm khác

Con trỏ không chỉ trỏ tới dữ liệu, mà còn có thể trỏ tới hàm. Điều này cực kỳ mạnh khi bạn cần viết hàm tổng quát, ví dụ như qsort.

Ví dụ cơ bản:

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int main() {
    int arr[] = {3, 1, 2};
    qsort(arr, 3, sizeof(int), compare);
}

Bạn cũng có thể viết hàm tự định nghĩa nhận con trỏ hàm làm tham số:

void apply(int *arr, int n, void (*func)(int*)) {
    for (int i = 0; i < n; i++) func(&arr[i]);
}

void double_value(int *x) {
    *x *= 2;
}

int main() {
    int nums[] = {1, 2, 3};
    apply(nums, 3, double_value);
    // nums = {2, 4, 6}
}

Pointer to function giúp chương trình linh hoạt và tái sử dụng cao, đặc biệt trong lập trình hướng cấu trúc.

Dùng const với pointer trong function

Để tránh lỗi vô ý thay đổi dữ liệu, bạn nên dùng const đúng cách.

Ví dụ:

void print_array(const int *arr, int n) {
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
}

Hàm này đảm bảo không làm thay đổi mảng gốc — điều này giúp compiler kiểm tra và bảo vệ dữ liệu an toàn hơn.

Các lỗi thường gặp khi dùng pointer trong function

1. Dereference con trỏ NULL
   → Luôn kiểm tra if (p == NULL) trước khi sử dụng.

2. Trả về địa chỉ biến cục bộ
   → Chỉ trả về con trỏ đến vùng nhớ được cấp phát trên heap.

3. Memory leak do quên free()
   → Ghi chú rõ ràng trong code: “Caller phải free vùng nhớ này”.

4. Double free
   → Sau khi free(p); nên p = NULL;.

5. Không kiểm tra kết quả của malloc/realloc
   → Mọi lệnh cấp phát nên được kiểm tra để tránh lỗi ngầm.

6. Gán sai kiểu con trỏ
   → Dùng ép kiểu (type*) cẩn trọng, tránh mất dữ liệu.

Lời khuyên thực hành và best practices

• Quản lý rõ ràng quyền sở hữu bộ nhớ: Ai malloc thì người đó phải free.

• Dùng const để bảo vệ dữ liệu.

• Luôn kiểm tra NULL trước khi dereference.

• Tránh pointer arithmetic phức tạp khi không cần thiết.

• Sử dụng công cụ kiểm tra bộ nhớ như Valgrind để phát hiện rò rỉ bộ nhớ.

• Viết tài liệu cho hàm có dùng con trỏ để người khác hiểu rõ cách dùng và trách nhiệm giải phóng bộ nhớ.

Kết luận

Qua bài viết này, bạn đã nắm được cách sử dụng pointer trong function — từ truyền tham chiếu, làm việc với mảng, trả về con trỏ, đến pointer to pointer và pointer to function. Đây là bước tiến lớn giúp bạn hiểu sâu hơn về cơ chế bộ nhớ, stack, heap và cách dữ liệu di chuyển giữa các hàm trong chương trình C.

Hãy thử áp dụng ngay bằng cách tự viết các hàm swap, append_value, allocate... và thực hành chúng trong dự án nhỏ. Khi bạn làm chủ con trỏ trong hàm, bạn không chỉ hiểu C ở mức cơ bản, mà đã tiến gần đến tư duy của một lập trình viên hệ thống thực thụ.

Nếu bạn muốn, mình có thể giúp bạn biên soạn một bộ bài tập luyện pointer trong function từ cơ bản đến nâng cao, giúp củng cố toàn bộ kiến thức đã học. Bạn có muốn mình gửi kèm phần đó không?