Friend functions have access only to public members of the class.

Đoạn mã C này duyệt qua chuỗi "man" và in ra các ký tự theo nhiều cách khác nhau.

* `s[i]` : Truy cập ký tự thứ `i` trong chuỗi `s` bằng cú pháp mảng.
* `*(s+i)` : Truy cập ký tự thứ `i` trong chuỗi `s` bằng cú pháp con trỏ. `s+i` trỏ đến địa chỉ của ký tự thứ `i`, và `*` giải tham chiếu để lấy giá trị tại địa chỉ đó.
* `*(i+s)` : Tương đương với `*(s+i)` do tính chất giao hoán của phép cộng.
* `i[s]` : Tương đương với `s[i]` theo định nghĩa của C. `a[i]` được định nghĩa là `*(a + i)` nên `i[a]` tương đương với `*(i + a)` hoặc `*(a + i)`.

Do đó, trong mỗi vòng lặp, mã sẽ in ra ký tự thứ `i` bốn lần, sau đó là một dấu tab (`\t`).

* Khi `i = 0`, ký tự là `m`, đầu ra là `mmmm`.
* Khi `i = 1`, ký tự là `a`, đầu ra là `aaaa`.
* Khi `i = 2`, ký tự là `n`, đầu ra là `nnnn`.

Vậy đáp án đúng là "mmmm aaa nnnn".

Đoạn code sử dụng vòng lặp `for` với biến `k` khởi tạo bằng -3, điều kiện lặp là `k < -5`, và bước lặp là `k++`. Vì giá trị khởi tạo của `k` là -3 đã không thỏa mãn điều kiện `k < -5` ngay từ đầu, vòng lặp sẽ không được thực thi. Do đó, lệnh `printf("Hello")` sẽ không bao giờ được gọi, và chương trình sẽ không in ra gì cả.

Đoạn mã này sử dụng một vòng lặp `while` để in ra các giá trị của biến `s`.

1. Khởi tạo: `s = 0`.
2. Vòng lặp `while`: Vòng lặp tiếp tục chừng nào `s++ < 10` còn đúng. Lưu ý rằng `s++` có nghĩa là giá trị của `s` được tăng lên sau khi nó được so sánh với 10.
3. Điều kiện `if`: `if (s < 4 && s < 9) continue;`. Nếu `s` nhỏ hơn 4 VÀ nhỏ hơn 9, lệnh `continue` sẽ được thực thi. Điều này có nghĩa là các lệnh còn lại trong vòng lặp sẽ bị bỏ qua và vòng lặp sẽ chuyển sang lần lặp tiếp theo.
4. `printf`: `printf(" %d ", s);`. Lệnh này in giá trị của `s` ra màn hình. Lệnh này chỉ được thực hiện nếu điều kiện `if` sai.

Phân tích từng bước:

- Lần lặp 1: `s = 0`. `s++ < 10` (0 < 10) là đúng. `s` trở thành 1. `s < 4 && s < 9` (1 < 4 && 1 < 9) là đúng. `continue` được thực thi. Không có gì được in ra.
- Lần lặp 2: `s = 1`. `s++ < 10` (1 < 10) là đúng. `s` trở thành 2. `s < 4 && s < 9` (2 < 4 && 2 < 9) là đúng. `continue` được thực thi. Không có gì được in ra.
- Lần lặp 3: `s = 2`. `s++ < 10` (2 < 10) là đúng. `s` trở thành 3. `s < 4 && s < 9` (3 < 4 && 3 < 9) là đúng. `continue` được thực thi. Không có gì được in ra.
- Lần lặp 4: `s = 3`. `s++ < 10` (3 < 10) là đúng. `s` trở thành 4. `s < 4 && s < 9` (4 < 4 && 4 < 9) là sai (vì 4 < 4 là sai). `printf` được thực thi. In ra 4.
- Lần lặp 5: `s = 4`. `s++ < 10` (4 < 10) là đúng. `s` trở thành 5. `s < 4 && s < 9` (5 < 4 && 5 < 9) là sai. `printf` được thực thi. In ra 5.
- Lần lặp 6: `s = 5`. `s++ < 10` (5 < 10) là đúng. `s` trở thành 6. `s < 4 && s < 9` (6 < 4 && 6 < 9) là sai. `printf` được thực thi. In ra 6.
- Lần lặp 7: `s = 6`. `s++ < 10` (6 < 10) là đúng. `s` trở thành 7. `s < 4 && s < 9` (7 < 4 && 7 < 9) là sai. `printf` được thực thi. In ra 7.
- Lần lặp 8: `s = 7`. `s++ < 10` (7 < 10) là đúng. `s` trở thành 8. `s < 4 && s < 9` (8 < 4 && 8 < 9) là sai. `printf` được thực thi. In ra 8.
- Lần lặp 9: `s = 8`. `s++ < 10` (8 < 10) là đúng. `s` trở thành 9. `s < 4 && s < 9` (9 < 4 && 9 < 9) là sai. `printf` được thực thi. In ra 9.
- Lần lặp 10: `s = 9`. `s++ < 10` (9 < 10) là đúng. `s` trở thành 10. `s < 4 && s < 9` (10 < 4 && 10 < 9) là sai. `printf` được thực thi. In ra 10.
- Lần lặp 11: `s = 10`. `s++ < 10` (10 < 10) là sai. Vòng lặp kết thúc.

Vậy đầu ra là: 4 5 6 7 8 9 10

Đoạn chương trình in ra các số từ 6 giảm dần đến 1. Hàm `print(int i)` in giá trị của `i` và trả về 0. Vòng lặp `while` tiếp tục thực hiện cho đến khi `print(i)` trả về giá trị khác 0 (true) hoặc `i` trở thành 0. Vì `print(i)` luôn trả về 0, vòng lặp `while` chỉ kết thúc khi `--i` làm cho `i` bằng 0. Như vậy, các số từ 6 đến 1 sẽ được in ra.