Tạo bởi Trần Văn Điêp|

Lập Trình C

[Video] Tìm hiểu pointer phần 1 - Lập Trình C

Mở bài

Nếu bạn đã từng học lập trình C, chắc chắn bạn sẽ nghe đến một “nhân vật quyền năng” mang tên pointer (con trỏ). Đây không chỉ là một khái niệm đơn thuần mà còn là trái tim của ngôn ngữ C – nơi giúp bạn hiểu sâu hơn về cách bộ nhớ máy tính hoạt động, dữ liệu được truy cập và chương trình vận hành bên trong.
Con trỏ giúp lập trình viên tối ưu hóa chương trình, truyền dữ liệu linh hoạt giữa các hàm, và quản lý bộ nhớ hiệu quả. Tuy nhiên, với người mới học, khái niệm con trỏ thường được xem là “khó nhằn” nhất, khiến nhiều bạn dễ nản.

Bài viết hôm nay sẽ là phần 1 trong chuỗi “Tìm hiểu Pointer trong C”, nơi bạn sẽ hiểu tường tận cách tổ chức bộ nhớ, cách khai báo biến con trỏ, ý nghĩa của toán tử * và &, cùng cách chúng hoạt động thực tế trong chương trình.
Hãy chuẩn bị tinh thần — bởi sau khi đọc xong bài viết này, bạn sẽ không còn thấy “con trỏ đáng sợ” nữa, mà sẽ coi nó là người bạn mạnh mẽ giúp bạn chinh phục lập trình C chuyên sâu.

Pointer là gì?

Khái niệm cơ bản

Trong ngôn ngữ C, pointer là một biến dùng để lưu địa chỉ của một biến khác. Thay vì lưu trữ trực tiếp giá trị như biến thông thường, con trỏ lưu trữ vị trí của vùng nhớ mà giá trị đó được đặt.

Ví dụ:


int x = 10;
int *p = &x;

x là một biến kiểu int chứa giá trị 10.
p là một con trỏ trỏ đến x, nghĩa là p lưu địa chỉ của x.
&x là toán tử “lấy địa chỉ của x”.
*p là “giá trị tại địa chỉ mà p đang trỏ tới”, tức là *p = 10.

Vì sao pointer quan trọng?

Hiểu cách bộ nhớ hoạt động: bạn sẽ biết từng giá trị nằm ở đâu trong RAM.
Truyền tham chiếu giữa các hàm: tiết kiệm bộ nhớ và tăng tốc độ xử lý.
Làm việc với mảng, chuỗi, cấu trúc dữ liệu động (linked list, tree, stack, queue...).
Cấp phát và thu hồi bộ nhớ thủ công – nền tảng cho các ứng dụng phức tạp.

Cách tổ chức bộ nhớ trong chương trình C

Bộ nhớ trong chương trình C thường được chia thành 4 vùng chính:

Code Segment (Text Segment):
- Chứa mã lệnh của chương trình (các hàm, lệnh thực thi).
Data Segment:
- Chứa các biến toàn cục hoặc tĩnh (static), đã được khởi tạo hoặc chưa.
Stack:
- Dành cho biến cục bộ và lời gọi hàm (mỗi lần bạn gọi một hàm mới, hệ thống cấp một khối nhớ mới).
Heap:
- Dùng để cấp phát bộ nhớ động (malloc, calloc, realloc, free).

Ví dụ:


void main() {
    int a = 5;      // nằm trên stack
    int *p;         
    p = &a;         // p lưu địa chỉ của a
    printf("%p", p); // hiển thị địa chỉ của a
}

Ở đây, a và p đều được tạo trong stack, nhưng p trỏ đến vị trí bộ nhớ nơi a đang nằm.
Hiểu cấu trúc bộ nhớ giúp bạn tránh lỗi phổ biến như dangling pointer, memory leak, hoặc segmentation fault.

Khai báo và khởi tạo biến con trỏ

Cú pháp khai báo con trỏ

Cú pháp chung:


kiểu_dữ_liệu *tên_biến_con_trỏ;

Ví dụ:


int *p;
char *c;
float *f;

Ở đây:

p là con trỏ đến kiểu int
c là con trỏ đến kiểu char
f là con trỏ đến kiểu float

Khởi tạo con trỏ

Con trỏ nên được gán địa chỉ của một biến cùng kiểu dữ liệu, ví dụ:


int x = 15;
int *p = &x;

Lưu ý quan trọng:

Không bao giờ sử dụng con trỏ chưa được khởi tạo (sẽ gây lỗi runtime).
Nếu chưa có giá trị, nên gán con trỏ bằng NULL:
```
int *p = NULL;
```

Minh họa trực quan

Giả sử:


int x = 100;
int *ptr = &x;

Ta có thể hình dung:

Tên biến	Giá trị (Value)	Địa chỉ (Address)
x	100	0x7ffee32c
ptr	0x7ffee32c	0x7ffee320

Như vậy, ptr không lưu giá trị 100, mà lưu địa chỉ nơi chứa giá trị 100.

Toán tử `&` và `*` trong con trỏ

Hai toán tử đặc biệt làm nên sức mạnh của con trỏ là & và *.

Toán tử `&` – Lấy địa chỉ

Toán tử & trả về địa chỉ bộ nhớ của biến.

Ví dụ:


int a = 7;
printf("%p", &a);

Kết quả sẽ hiển thị một giá trị kiểu địa chỉ, ví dụ 0x7ffee3a1bcd8.

Toán tử `*` – Truy cập giá trị tại địa chỉ

Toán tử * được gọi là toán tử giải tham chiếu (dereference).
Nó giúp bạn lấy giá trị được lưu tại địa chỉ mà con trỏ đang trỏ tới.

Ví dụ:


int a = 7;
int *p = &a;

printf("%d", *p); // Kết quả: 7

Ở đây:

p → lưu địa chỉ của a
*p → giá trị tại địa chỉ đó, tức là 7

Mối liên hệ giữa `&` và `*`

Hai toán tử này là “cặp đôi nghịch đảo”:


int x = 5;
int *p = &x;

printf("%d", *(&x)); // Kết quả: 5
printf("%p", &(*p)); // Kết quả: địa chỉ của x

Hiểu rõ cách dùng * và & là bước đầu tiên để làm chủ con trỏ trong C.

Ví dụ minh họa con trỏ trong thực tế

Ví dụ 1: Hoán đổi hai số bằng con trỏ


#include <stdio.h>

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

int main() {
    int x = 5, y = 10;
    swap(&x, &y);
    printf("x = %d, y = %d", x, y);
    return 0;
}

Phân tích:

Hàm swap nhận con trỏ đến hai biến x, y.
Dùng *a và *b để truy cập giá trị thực sự và hoán đổi.
Giúp tiết kiệm bộ nhớ và tránh sao chép dữ liệu lớn khi truyền vào hàm.

Ví dụ 2: Truy cập mảng bằng con trỏ


int arr[3] = {10, 20, 30};
int *p = arr;

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

Kết quả: 10 20 30

Con trỏ p trỏ đến phần tử đầu tiên của mảng, và phép p + i giúp truy cập các phần tử tiếp theo. Đây là nguyên tắc con trỏ – mảng tương đương trong C.

Lỗi thường gặp khi làm việc với pointer

Sử dụng con trỏ chưa khởi tạo:


int *p;
*p = 10; // Sai! p chưa trỏ đến vùng nhớ hợp lệ

Giải phóng bộ nhớ nhiều lần (double free)
Truy cập vùng nhớ bị thu hồi (dangling pointer)

Gán sai kiểu dữ liệu:


int x = 10;
float *p = &x; // Sai, kiểu không tương thích

👉 Mẹo:

Luôn gán NULL cho con trỏ sau khi giải phóng:
```
free(p);
p = NULL;
```

Kết luận

Qua bài viết này, bạn đã hiểu rõ khái niệm pointer, cách bộ nhớ được tổ chức, cách khai báo, khởi tạo con trỏ, cùng ý nghĩa của toán tử * và &.
Con trỏ không chỉ giúp bạn hiểu sâu hơn về cơ chế hoạt động của ngôn ngữ C, mà còn là nền tảng cho lập trình cấp cao hơn như quản lý bộ nhớ động, cấu trúc dữ liệu, hoặc thao tác file, chuỗi, mảng nâng cao.

Hãy dành thời gian thực hành lại các ví dụ trong bài, tự mình viết code, thử in ra địa chỉ, giá trị, và quan sát thay đổi. Khi bạn đã cảm thấy thoải mái với * và &, thì bạn đã bước chân vào thế giới chuyên nghiệp của lập trình C.

💡 Trong phần 2, chúng ta sẽ tiếp tục khám phá: