Biến con trỏ có thể chứa:

Đoạn chương trình C này thực hiện các phép toán trên con trỏ. Ban đầu, `px` trỏ đến phần tử đầu tiên của mảng `a`, và `py` trỏ đến phần tử cuối cùng (a[5]).

`px = a;` gán địa chỉ của `a[0]` cho `px`.
`py = &a[5];` gán địa chỉ của `a[5]` cho `py`.
`++px` tăng giá trị của con trỏ `px` lên một đơn vị. Vì `px` là con trỏ kiểu `int`, nó sẽ trỏ đến phần tử kế tiếp trong mảng (tức là `a[1]`).

Biểu thức `++px - py` thực hiện phép trừ hai con trỏ. Kết quả là số lượng phần tử kiểu `int` giữa hai địa chỉ. Sau khi `px` tăng lên, `px` trỏ đến `a[1]` và `py` trỏ đến `a[5]`. Vậy số phần tử giữa `a[1]` và `a[5]` là 5 - 1 = 4.
Tuy nhiên, vì biểu thức là `++px - py`, nên ta phải hiểu rằng `++px` trả về địa chỉ *sau khi* tăng. Vì vậy, `px` trỏ đến `a[1]`. Vậy nên, `px - py` sẽ bằng (địa chỉ của a[1] - địa chỉ của a[5])/sizeof(int), tức là (1 - 5) = -4.

Vậy kết quả in ra sẽ là -4.

Câu hỏi kiểm tra về cú pháp khai báo cấu trúc (struct) trong C/C++.

Phương án A đúng: Khai báo một struct tên là Date với các thành viên ngay, thang, nam kiểu int.
Phương án B đúng: Khai báo trực tiếp hai biến D1, D2 kiểu struct với các thành viên ngay, thang, nam kiểu int. Tuy nhiên, cách khai báo này không định nghĩa một kiểu dữ liệu struct cụ thể nào có tên.
Phương án C đúng: Sử dụng typedef để định nghĩa một kiểu dữ liệu mới là Date, tương đương với struct { int ngay, thang, nam; }. Sau đó, Date có thể được sử dụng như một kiểu dữ liệu.
Phương án D sai: Khai báo struct Date với các trường bitfields ngay (7 bits), thang (6 bits) và nam (5 bits). Đây là một cách khai báo hợp lệ, tuy nhiên, có một lỗi tiềm ẩn là kiểu dữ liệu `long int` có thể không đủ lớn để chứa các giá trị ngày, tháng, năm. Ngoài ra việc sử dụng `long int` cho bitfield có thể gây ra warning hoặc lỗi biên dịch tùy theo compiler. Tuy nhiên, về mặt cú pháp thì khai báo này vẫn có thể được chấp nhận bởi một số trình biên dịch C/C++.

Tuy nhiên, trong các phương án trên, phương án D có khả năng gây ra lỗi hoặc warning nhiều nhất, do đó, có thể xem nó là "không đúng" nhất. Nếu đề bài yêu cầu tìm phương án sai về mặt *ý nghĩa* (logic) thì D phù hợp hơn, còn nếu xét về mặt *cú pháp* thì A,B,C đều đúng cú pháp.

Vì đề bài hỏi "khai báo nào *không đúng*" và xét về khả năng gây lỗi/warning thì D có khả năng cao hơn.

Trong ngôn ngữ lập trình C, các hàm cấp phát bộ nhớ động bao gồm `malloc()`, `calloc()`, và `realloc()`. Tuy nhiên, `malloc()` là hàm cấp phát bộ nhớ động cơ bản nhất và thường được sử dụng để cấp phát bộ nhớ cho các kiểu dữ liệu do người dùng định nghĩa như struct và union.

- `malloc()`: Cấp phát một khối bộ nhớ có kích thước được chỉ định, nhưng không khởi tạo giá trị cho vùng nhớ đó.
- `calloc()`: Cấp phát một khối bộ nhớ cho một mảng các phần tử, và khởi tạo tất cả các byte của vùng nhớ đó về 0.
- `realloc()`: Thay đổi kích thước của một khối bộ nhớ đã được cấp phát trước đó.

Mặc dù cả ba hàm đều liên quan đến cấp phát bộ nhớ động, nhưng `malloc()` thường được sử dụng trực tiếp và phổ biến nhất cho việc cấp phát bộ nhớ cho các cấu trúc và hợp nhất (struct và union) do lập trình viên định nghĩa. Do đó, đáp án B là chính xác nhất trong ngữ cảnh này.

Phương án A sai vì gán `head->next` bằng `head` sẽ tạo một vòng lặp, khiến phần tử đầu tiên trỏ lại chính nó, chứ không xóa nó khỏi danh sách.

Phương án B đúng vì `head = head->next;` sẽ gán địa chỉ của phần tử thứ hai cho con trỏ `head`. Như vậy, phần tử đầu tiên sẽ không còn được trỏ tới bởi `head` và do đó bị loại khỏi danh sách (nếu không có con trỏ nào khác trỏ tới nó).

Phương án C sai vì `head = head->next->next;` sẽ gán địa chỉ của phần tử thứ ba cho con trỏ `head`. Như vậy, hai phần tử đầu tiên sẽ không còn được trỏ tới bởi `head` và do đó bị loại khỏi danh sách (nếu không có con trỏ nào khác trỏ tới chúng). Tuy nhiên, câu hỏi yêu cầu xóa phần tử đầu tiên, nên phương án này không phù hợp.

Phương án D sai vì chỉ có B đúng.

Vậy đáp án đúng là B.

Câu hỏi kiểm tra cách truy cập vào các thành phần của một struct trong C khi sử dụng con trỏ. Trong đoạn mã cho trước, SV1 là một biến kiểu struct SV, và p là một con trỏ trỏ đến SV1.

* A. SV1.hoten;: Đây là cách truy cập chính xác vào thành viên hoten của struct SV1 khi bạn trực tiếp làm việc với biến SV1. Toán tử `.` được sử dụng để truy cập thành viên của một struct thông qua tên biến struct.
* B. p->hoten;: Đây cũng là một cách truy cập chính xác. Khi p là một con trỏ đến struct SV1, toán tử `->` được sử dụng để truy cập thành viên hoten của struct mà p đang trỏ tới. `p->hoten` tương đương với `(*p).hoten`.
* C. &hoten;: Đây là sai. `&hoten` sẽ trả về địa chỉ của biến `hoten`, nhưng không có ngữ cảnh nào cho biết `hoten` thuộc về struct SV1. Do đó, nó không phải là cách biểu diễn chính xác để truy cập vào phần tử hoten của SV1.
* D. A và B đều đúng: Vì cả A và B đều là các phương pháp chính xác để truy cập vào thành viên hoten của struct SV1, nên đáp án này là đúng.

Vậy, đáp án đúng là D.