Kiểu dữ liệu int( kiểu số nguyên) có thể xử lí số nguyên nằm trong khoảng nào

Đ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.

Đ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