Kết quả của chương trình sau là gì:
#include
void hoanvi(int *px, int *py)
{
            int z ;
            z=*px;
            *px=*py ;
            *py=z ;
} ;
void main()
{
            int a=15, b=21 ; hoanvi(a,b) ;
            printf (“%d %d”,a,b);
}; 

Xâu định dạng "%e" được sử dụng để in ra một số thực có độ chính xác kép (double) ở dạng ký hiệu khoa học. Các xâu định dạng khác không phù hợp:
- "%u": Dùng cho số nguyên không dấu.
- "%o": Dùng cho số nguyên hệ bát phân.
- "%p": Dùng để in ra địa chỉ con trỏ (pointer).

Kiểu dữ liệu `int` trong các ngôn ngữ lập trình (ví dụ: C, C++, Java) thường được biểu diễn bằng 2 bytes (16 bits). Phạm vi giá trị mà kiểu `int` có thể lưu trữ, khi sử dụng biểu diễn số bù hai, là từ -32768 đến 32767. Do đó, đáp án B là chính xác. Các đáp án còn lại không đúng với phạm vi giá trị của kiểu `int` thông thường.

Đoạn chương trình sử dụng `printf` với định dạng `%o` để in giá trị của biến `i` dưới dạng số bát phân (hệ cơ số 8).

Biến `i` được gán giá trị là 10 (hệ thập phân).

Để chuyển 10 từ hệ thập phân sang hệ bát phân, ta thực hiện như sau:

10 chia 8 được 1, dư 2.

Vậy, 10 (hệ thập phân) = 12 (hệ bát phân).

Do đó, chương trình sẽ in ra `12`.

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

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.