Kết quả của chương trình sau
#include “stdio.h”
void main() {
int i;
i = 10;
printf(“ % o”, i);
}

Chương trình thực hiện phép chia số nguyên `a` cho số nguyên `b`, sau đó ép kiểu cả hai thành số thực trước khi thực hiện phép chia.
`a` = 100, `b` = 6.
`f` = (double) `a` / (double) `b` = 100.0 / 6.0 = 16.6666...
Câu lệnh `printf(“ % 2.2 f”, f);` định dạng số thực `f` thành một chuỗi có độ rộng tối thiểu là 2 và có 2 chữ số phần thập phân. Do đó, kết quả in ra sẽ là " 16.67".

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.