Xâu định dạng nào dưới đây dùng để in ra một số thực có độ chính xác kép

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.

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.