Kết quả in ra màn hình của chương trình sau:
#include
void main() {
char * s;
s = ”chao cac ban”;
strcpy( & s[5], & s[9]);
printf(“ % s”, s);
};

Đoạn chương trình thực hiện phép gán và sử dụng toán tử tăng trước (++). Ban đầu, biến `p` được khởi tạo bằng 4. Sau đó, biểu thức `10 + ++p` được tính toán. Toán tử `++p` tăng giá trị của `p` lên 1 trước khi sử dụng, do đó `p` trở thành 5. Sau đó, 10 được cộng với 5, kết quả là 15. Giá trị này được gán lại cho `p`. Vậy kết quả cuối cùng của `p` là 15.

Phép trừ hai con trỏ cùng kiểu trong C/C++ (và các ngôn ngữ tương tự) trả về một số nguyên (thường là `ptrdiff_t`). Số nguyên này biểu thị số lượng phần tử (có kiểu dữ liệu mà con trỏ trỏ tới) giữa hai con trỏ đó. Ví dụ, nếu `p` và `q` là hai con trỏ kiểu `int`, và `p` trỏ tới phần tử thứ 10 của một mảng `int`, còn `q` trỏ tới phần tử thứ 5, thì `p - q` sẽ bằng 5.

Chương trình C này thực hiện các bước sau:
1. Khai báo một biến nguyên `x` và một con trỏ `p` trỏ đến kiểu nguyên.
2. Gán giá trị 6 cho biến `x`.
3. Gán địa chỉ của biến `x` cho con trỏ `p`.
4. In giá trị của `x` ra màn hình bằng hàm `printf`. Kết quả là 6.
5. In giá trị mà con trỏ `p` đang trỏ tới ra màn hình. Vì `p` đang trỏ tới `x`, nên giá trị mà `*p` trả về cũng là 6.

Hàm `printf` in các giá trị mà không có khoảng trắng giữa chúng. Do đó, kết quả in ra sẽ là 66.

Đoạn chương trình trên thực hiện một vòng lặp `for` với biến `i` khởi tạo bằng 1. Vòng lặp tiếp tục cho đến khi `i` không còn nhỏ hơn 5 nữa (`i < 5`). Trong mỗi lần lặp, biến `k` được tăng lên 1 (`k++`).

- Ban đầu, `i = 1` và `k = 0`.
- Lần lặp 1: `i = 1 < 5` là đúng, `k` tăng lên thành 1.
- Lần lặp 2: `i` tăng lên thành 2, `i = 2 < 5` là đúng, `k` tăng lên thành 2.
- Lần lặp 3: `i` tăng lên thành 3, `i = 3 < 5` là đúng, `k` tăng lên thành 3.
- Lần lặp 4: `i` tăng lên thành 4, `i = 4 < 5` là đúng, `k` tăng lên thành 4.
- Lần lặp 5: `i` tăng lên thành 5, `i = 5 < 5` là sai, vòng lặp kết thúc.

Vậy, sau khi vòng lặp kết thúc, giá trị của `k` là 4. Chương trình in ra giá trị của `k`.

Đoạn chương trình sử dụng hàm `scanf` để đọc dữ liệu từ đầu vào chuẩn. Cụ thể, nó cố gắng đọc một số nguyên (`%d`) vào biến `n` và một ký tự (`%c`) vào biến `c`. Định dạng chuỗi `" %d %c"` có một khoảng trắng trước `%d`. Khoảng trắng này có nghĩa là `scanf` sẽ bỏ qua bất kỳ khoảng trắng nào (ví dụ: dấu cách, tab, dòng mới) ở đầu vào cho đến khi nó tìm thấy một ký tự không phải khoảng trắng để chuyển đổi thành một số nguyên. Sau khi đọc số nguyên, `scanf` sẽ đọc ký tự tiếp theo vào biến `c`. Trong trường hợp đầu vào là "10 T", `scanf` sẽ đọc số 10 vào `n`. Sau đó, nó sẽ đọc ký tự 'T' vào `c`. Vậy, `n` sẽ có giá trị 10 và `c` sẽ có giá trị 'T'.