Kết quả in ra màn hình của chương trình sau:
#include
void main() {
int a = 100, b = 6;
double f;
f = (double) a / (double) b;
printf(“ % 2.2 f”, f);
};

Trong C/C++, con trỏ void (void *) là một con trỏ tổng quát, có thể trỏ đến bất kỳ kiểu dữ liệu nào. Tuy nhiên, khi gán giá trị từ một con trỏ void cho một con trỏ kiểu cụ thể, ta cần ép kiểu tường minh.

* A. `tongquat = nguyen;`: Hợp lệ. Gán con trỏ `nguyen` (kiểu `int *`) cho con trỏ `tongquat` (kiểu `void *`). Vì `void *` có thể trỏ đến bất kỳ kiểu dữ liệu nào, việc này không gây ra lỗi.
* B. `*nguyen = *tongquat;`: Không hợp lệ. `tongquat` là con trỏ `void`, nên trình biên dịch không biết kiểu dữ liệu mà nó đang trỏ tới. Do đó, không thể giải tham chiếu `*tongquat` để lấy giá trị và gán cho `*nguyen` (kiểu `int`). Cần phải ép kiểu `tongquat` về `int *` trước khi giải tham chiếu, ví dụ: `*nguyen = *(int*)tongquat;`
* C. `kitu = (char*)tongquat;`: Hợp lệ. Ép kiểu tường minh con trỏ `tongquat` (kiểu `void *`) về `char *` và gán cho `kitu`.
* D. `tongquat = kitu;`: Hợp lệ. Gán con trỏ `kitu` (kiểu `char *`) cho con trỏ `tongquat` (kiểu `void *`).

Vậy, phép gán không hợp lệ là B.

Chương trình C này có một vòng lặp `for` không có điều kiện dừng (`;;`). Điều này có nghĩa là vòng lặp sẽ tiếp tục chạy mãi mãi. Bên trong vòng lặp, biến `k` được gán giá trị `5` trong mỗi lần lặp, nhưng điều này không ảnh hưởng đến giá trị của `i`. Biến `i` được tăng lên mỗi lần lặp. Tuy nhiên, lệnh `printf` nằm *bên ngoài* vòng lặp, và vòng lặp này không bao giờ kết thúc, do đó lệnh `printf` không bao giờ được thực thi. Do đó, chương trình sẽ rơi vào vòng lặp vô hạn và không in ra bất cứ giá trị nào.

Đoạn chương trình trên có một lỗi rất dễ nhận thấy. Vòng lặp `for` có dấu chấm phẩy (`;`) ngay sau điều kiện lặp `i <= 24;`. Điều này có nghĩa là thân vòng lặp là một câu lệnh rỗng. Do đó, vòng lặp sẽ chạy từ `i = 1` đến `i = 25` (sau lần tăng cuối cùng, điều kiện `i <= 24` không còn đúng). Sau khi vòng lặp kết thúc, `i` sẽ có giá trị là 25. Sau đó, lệnh `printf` sẽ in ra giá trị của `i`, tức là 25. Vì vậy đáp án C là đáp án đúng

Hàm `gotoxy(int x, int y)` trong lập trình (thường thấy trong thư viện `conio.h` của Turbo C++) được sử dụng để di chuyển con trỏ màn hình đến vị trí được chỉ định bởi tọa độ `(x, y)`, trong đó `x` là chỉ số cột và `y` là chỉ số dòng. Vì vậy, hàm này đặt con trỏ tại cột `x` và dòng `y` trên màn hình.

Câu hỏi yêu cầu khai báo hàm tìm giá trị lớn nhất trong một mảng các số kiểu `long`.

* Phương án A: `void Max(long *a);`
* Sai. Thiếu thông tin về số lượng phần tử trong mảng. Hàm không biết mảng có bao nhiêu phần tử để duyệt.
* Phương án B: `long Max(long *a[]);`
* Sai. Tham số `long *a[]` là một mảng các con trỏ kiểu `long`, không phải mảng các số `long`. Ngoài ra, cũng thiếu thông tin về số lượng phần tử.
* Phương án C: `void Max(long a[], int n);`
* Sai. Hàm `void Max` không trả về giá trị lớn nhất tìm được. Hơn nữa, mặc dù có kích thước mảng `n`, hàm này cũng không trả về giá trị lớn nhất.
* Phương án D: `long Max(long *a, int n);`
* Đúng. Tham số `long *a` là một con trỏ đến phần tử đầu tiên của mảng các số `long`, và `int n` là số lượng phần tử trong mảng. Hàm trả về giá trị `long`, là giá trị lớn nhất tìm được trong mảng.

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