What is output? void main() { int ints[] = { 0, 5, 10, 15 }; int* i2 = ints + 2; int a = *i2++; // a = *(i2++); printf("%d#%d\n", a, *i2); getch(); }

Đoạn code khai báo một mảng tĩnh `a` gồm 20 số nguyên. Vì là mảng tĩnh nên các phần tử của mảng sẽ được khởi tạo mặc định là 0. Sau đó, gán `a[0] = 0`. Cuối cùng in ra `a[0]`, `a[1]` và `i`. Vì `a[0]` đã được gán bằng 0, `a[1]` không được gán nên vẫn là 0, và `i` cũng bằng 0. Do đó, kết quả in ra sẽ là `0 0 0`.

Đoạn mã C được cung cấp thực hiện các phép toán trên các biến `i` và `j`. Ban đầu, `i` được gán giá trị 5 và `j` được gán giá trị 2. Sau đó, `i` được tăng lên 7 (`i = i + j`). Tiếp theo, `j` được nhân với `i`, kết quả là `j = 2 * 7 = 14`. Cuối cùng, `i` lại được tăng thêm `j`, tức là `i = 7 + 14 = 21`. Vì vậy, giá trị cuối cùng của `i` là 21. Không có đáp án nào trùng khớp.

Đầu tiên, ta khai báo các biến `i = 1`, `j = 5`, `k`.

Sau đó, gán `k = ++i || ++j;`

`++i` là tiền tố tăng, nên `i` tăng lên 2 trước khi được sử dụng trong biểu thức. Vì `i = 2` khác 0 (true), nên biểu thức `++i || ++j` sẽ chỉ xét `++i`, và không xét `++j` (do `||` là phép toán OR, nếu vế trái đúng thì không cần xét vế phải).

Vậy, `k = i = 2`.

Tiếp theo, gán `k && ++j;`

`k && ++j` nghĩa là nếu `k` khác 0 (true) thì thực hiện `++j`. Vì `k = 2` khác 0, nên `++j` được thực hiện. `++j` là tiền tố tăng, nên `j` tăng lên 6 trước khi được sử dụng. Tuy nhiên, giá trị của biểu thức `k && ++j` không được gán cho bất kỳ biến nào, do đó giá trị của `j` sau khi tăng lên sẽ không ảnh hưởng đến các biến khác.

Cuối cùng, in ra giá trị của `i`, `j`, `k`.

`printf("%d %d %d", i, j, k);`

Vậy, kết quả in ra là `2 5 2`.

Tuy nhiên không có đáp án nào trùng với kết quả tính toán, vậy đáp án đúng là D. Một cái khác

Đề bài cho đoạn code C với một struct và yêu cầu xác định kết quả khi chạy chương trình.

Struct `A` có 3 trường: `x` (char), `y` (float), `z` (int). Do có hiện tượng padding trong struct để đảm bảo các biến thành viên được căn chỉnh theo địa chỉ thích hợp, nên kích thước của struct `A` sẽ được tính như sau:

- `x` (char): 1 byte
- `y` (float): 4 byte. `x` sẽ được padding thêm 3 byte để `y` bắt đầu ở địa chỉ chia hết cho 4.
- `z` (int): 4 byte.

Tổng kích thước struct `A` là 1 + 3 + 4 + 4 = 12 bytes.

Mảng `arr` có 5 phần tử, mỗi phần tử là kiểu struct `A`. Vậy kích thước của mảng là 5 * 12 = 60 bytes.

`A *p = arr;` khai báo con trỏ `p` kiểu `A*` và gán cho nó địa chỉ của phần tử đầu tiên trong mảng `arr`.

`A *q = arr + 3;` khai báo con trỏ `q` kiểu `A*` và gán cho nó địa chỉ của phần tử thứ 4 trong mảng `arr` (arr[3]).

`long k = q - p;` tính khoảng cách giữa địa chỉ của `q` và `p`. Do `q` và `p` đều là con trỏ kiểu `A*`, kết quả phép trừ sẽ là số phần tử kiểu `A` giữa `q` và `p`, tức là 3. Vì k là long, có kích thước 4 byte, nên giá trị của k sẽ là 3.

`int t = (int)( (char*)q - (char*)p );` ép kiểu `q` và `p` sang `char*`, sau đó tính hiệu. Lúc này, hiệu là số byte giữa hai con trỏ. Khoảng cách giữa `q` và `p` là 3 * sizeof(A) = 3 * 12 = 36 bytes. Vì t là int, kích thước 4 byte, nên giá trị của t sẽ là 36.

`char h = (char)( (int)q - (int)p );` ép kiểu `q` và `p` sang `int`, sau đó tính hiệu (36). Vì h là char, kích thước 1 byte, nên giá trị của h sẽ là 36 % 256 = 36.

Vậy, kết quả in ra sẽ là: 8 4 1.