Anh (Chị) hãy cho biết kết quả của đoạn lệnh sau là gì?
void inc (void* data, int psize) {
if (psize == sizeof (char)) {
char* pchar;
pchar = (char*)data;
++(*pchar);
} else if (psize == sizeof(int)) {
int* pint; pint = (int*)data;
++(*pint);
}
}
int main() { char c = 'y'; inc (&s,sizeof(s));
cout << s << endl;
return 0;
}
Trả lời:
Đáp án đúng: D
Đoạn chương trình trên thực hiện tăng giá trị của một biến kiểu `char` hoặc `int` thông qua con trỏ. Trong hàm `main`, biến `c` được khởi tạo với giá trị 'y'. Sau đó, hàm `inc` được gọi với địa chỉ của `c` và kích thước của `c`. Vì kích thước của `c` là `sizeof(char)`, nhánh `if (psize == sizeof (char))` được thực thi. Trong nhánh này, con trỏ `pchar` được gán địa chỉ của `c`, và `++(*pchar)` tăng giá trị của ký tự mà `pchar` trỏ tới. Do đó, 'y' tăng lên thành 'z'. Cuối cùng, giá trị của `c` ('z') được in ra màn hình.
Vậy đáp án đúng là C.
Câu hỏi liên quan
Lời giải:
Đáp án đúng: D
Đề bài yêu cầu tìm kết quả của chương trình C++ khi chạy với dòng lệnh `test 3 3`. Ta cần phân tích code để xem chương trình thực hiện phép tính gì.
* `int main(int argc,char* argv[])`: Hàm `main` nhận hai tham số: `argc` (số lượng tham số dòng lệnh) và `argv` (mảng các chuỗi tham số).
* `double s = 1;`: Khởi tạo biến `s` kiểu `double` với giá trị ban đầu là 1.
* `for (int i = 0; i < argv[2]; i++) s += atof(argv[1]);`: Vòng lặp này lặp lại một số lần phụ thuộc vào giá trị của `argv[2]`. Trong mỗi lần lặp, giá trị của `argv[1]` (được chuyển đổi sang kiểu `double` bằng hàm `atof`) được cộng vào `s`.
* `cout << s << endl;`: In giá trị của `s` ra màn hình.
Trong trường hợp này, khi chạy lệnh `test 3 3`, ta có:
* `argc = 3` (tên chương trình, tham số thứ nhất, tham số thứ hai).
* `argv[0] = "test"`
* `argv[1] = "3"`
* `argv[2] = "3"`
Vòng lặp `for` sẽ lặp lại `argv[2]` lần, tức là 3 lần. Trong mỗi lần lặp, `atof(argv[1])` sẽ chuyển đổi chuỗi "3" thành số thực 3.0, và cộng vào `s`.
Vậy, `s` sẽ được tính như sau:
`s = 1 + 3 + 3 + 3 = 10`
Tuy nhiên, có một lỗi cú pháp trong vòng lặp `for`. Biểu thức điều kiện `i < argv[2]` không đúng vì `argv[2]` là một chuỗi (char*), không phải là một số nguyên. Do đó, chương trình sẽ không biên dịch được.
Vậy đáp án đúng là D.
Lời giải:
Đáp án đúng: D
Đoạn code khởi tạo một mảng 2 chiều `number` kích thước 3x3 và một biến `s` để tính tổng. Vòng lặp `for` duyệt qua các phần tử trên đường chéo chính của mảng, gán giá trị từ `n` giảm dần và cộng vào `s`.
Giá trị của `n` khởi đầu là 10. Trong mỗi lần lặp, `number[i][j]` được gán giá trị của `n`, sau đó `n` giảm đi 1. Các giá trị của `number[i][j]` và `s` trong mỗi lần lặp như sau:
- Lần lặp 1: `i = 0`, `j = 0`, `number[0][0] = 10`, `n = 9`, `s = 10`
- Lần lặp 2: `i = 1`, `j = 1`, `number[1][1] = 9`, `n = 8`, `s = 10 + 9 = 19`
- Lần lặp 3: `i = 2`, `j = 2`, `number[2][2] = 8`, `n = 7`, `s = 19 + 8 = 27`
Vậy kết quả cuối cùng của `s` là 27.
Lưu ý: Biểu thức điều kiện `i < 3, j < 3` trong vòng lặp `for` chỉ xét `j < 3`, vì toán tử `,` sẽ trả về toán hạng cuối cùng. Do đó, vòng lặp sẽ tiếp tục cho đến khi `j` đạt giá trị 3.
Lời giải:
Đáp án đúng: B
Đoạn code trên thực hiện một vòng lặp 3 lần, trong đó có một hàm `inc` được gọi để tăng giá trị của biến `ten` kiểu `char`. Hàm `inc` nhận một con trỏ `void*` và kích thước của dữ liệu. Nếu kích thước dữ liệu là kích thước của `char`, nó sẽ ép kiểu con trỏ `void*` thành `char*` và tăng giá trị của biến được trỏ đến. Trong vòng lặp, biến `ten` được khởi tạo là 'A'.
Trong mỗi lần lặp:
- `hs[i].hoten` được gán giá trị của `ten`.
- `hs[i].namsinh` được gán giá trị `1990 + i`.
- Hàm `inc` được gọi để tăng `ten`.
Vậy:
- Lần lặp 1: `ten` = 'A', `hs[0].hoten` = 'A', `hs[0].namsinh` = 1990, `ten` tăng thành 'B'.
- Lần lặp 2: `ten` = 'B', `hs[1].hoten` = 'B', `hs[1].namsinh` = 1991, `ten` tăng thành 'C'.
- Lần lặp 3: `ten` = 'C', `hs[2].hoten` = 'C', `hs[2].namsinh` = 1992, `ten` tăng thành 'D'.
Cuối cùng, `cout` in ra `hs[1].hoten` và `hs[1].namsinh`. Theo như phân tích, `hs[1].hoten` = 'B' và `hs[1].namsinh` = 1991.
Lời giải:
Đáp án đúng: A
Đoạn code C++ này sử dụng một struct `hocsinh` để lưu trữ thông tin học sinh (tên và năm sinh). Chương trình tạo một mảng `hs` gồm 3 học sinh, sau đó sử dụng con trỏ `p` để duyệt và gán giá trị cho `namsinh` của từng học sinh. Ban đầu, vòng lặp gán `namsinh` cho các học sinh trong mảng `hs` như sau:
- hs[0].namsinh = 1991 + 0 = 1991
- hs[1].namsinh = 1991 + 1 = 1992
- hs[2].namsinh = 1991 + 2 = 1993
Sau vòng lặp, con trỏ `p` được gán lại bằng `hs + 1`, tức là `p` trỏ đến `hs[1]`. Sau đó, `hs[1].namsinh` được giảm đi 20 đơn vị: `hs[1].namsinh = 1992 - 20 = 1972`.
Cuối cùng, chương trình in ra giá trị của `hs[1].namsinh`, là 1972.
Vậy đáp án đúng là A. 1972
Lời giải:
Đáp án đúng: C
Phân tích lỗi trong chương trình C++:
* **Dòng 9:** `p->namsinh = 1991 + i;`
* Lỗi: Không có lỗi cú pháp, nhưng về mặt logic, dòng này đang gán giá trị cho `namsinh` của phần tử hiện tại mà con trỏ `p` đang trỏ tới.
* **Dòng 12:** `*p = hs+1;`
* Lỗi: Dòng này cố gắng gán địa chỉ `hs+1` (địa chỉ của phần tử thứ hai trong mảng `hs`) cho *giá trị* mà con trỏ `p` đang trỏ tới. Đây là một lỗi nghiêm trọng vì kiểu dữ liệu không tương thích. `*p` có kiểu `hocsinh`, trong khi `hs+1` có kiểu `hocsinh*`. Bạn không thể gán một con trỏ cho một biến cấu trúc trực tiếp như vậy. Hơn nữa, sau vòng lặp, `p` đã trỏ ra ngoài mảng `hs`, nên việc truy cập `*p` sẽ gây ra lỗi runtime (segmentation fault hoặc tương tự).
* **Dòng 13:** `p.namsinh -= 20;`
* Lỗi: `p` là một con trỏ (`hocsinh *`). Để truy cập thành viên của cấu trúc mà `p` trỏ tới, bạn cần sử dụng toán tử `->`, không phải `.`. Cách viết đúng phải là `p->namsinh -= 20;`.
* **Dòng 14:** `cout << *p.namsinh << endl;`
* Lỗi: Tương tự như dòng 13, `p` là một con trỏ, nên phải sử dụng `->`. Ngoài ra, `p->namsinh` là một số nguyên (kiểu `int`), không phải con trỏ. Việc sử dụng `*` trước `p->namsinh` là sai. Hơn nữa, sau khi gán sai ở dòng 12, `p` có thể trỏ đến một vùng nhớ không hợp lệ, do đó việc truy cập `*p.namsinh` (nếu cú pháp đúng) có thể gây ra lỗi runtime.
Như vậy, các dòng sai là 12, 13 và 14.
Lời giải:
Bạn cần đăng ký gói VIP để làm bài, xem đáp án và lời giải chi tiết không giới hạn. Nâng cấp VIP
Lời giải:
Bạn cần đăng ký gói VIP để làm bài, xem đáp án và lời giải chi tiết không giới hạn. Nâng cấp VIP
Lời giải:
Bạn cần đăng ký gói VIP để làm bài, xem đáp án và lời giải chi tiết không giới hạn. Nâng cấp VIP
Lời giải:
Bạn cần đăng ký gói VIP để làm bài, xem đáp án và lời giải chi tiết không giới hạn. Nâng cấp VIP
Lời giải:
Bạn cần đăng ký gói VIP để làm bài, xem đáp án và lời giải chi tiết không giới hạn. Nâng cấp VIP

Bộ Đồ Án Tốt Nghiệp Ngành Trí Tuệ Nhân Tạo Và Học Máy
89 tài liệu310 lượt tải

Bộ 120+ Đồ Án Tốt Nghiệp Ngành Hệ Thống Thông Tin
125 tài liệu441 lượt tải

Bộ Đồ Án Tốt Nghiệp Ngành Mạng Máy Tính Và Truyền Thông
104 tài liệu687 lượt tải

Bộ Luận Văn Tốt Nghiệp Ngành Kiểm Toán
103 tài liệu589 lượt tải

Bộ 370+ Luận Văn Tốt Nghiệp Ngành Kế Toán Doanh Nghiệp
377 tài liệu1030 lượt tải

Bộ Luận Văn Tốt Nghiệp Ngành Quản Trị Thương Hiệu
99 tài liệu1062 lượt tải
ĐĂNG KÝ GÓI THI VIP
- Truy cập hơn 100K đề thi thử và chính thức các năm
- 2M câu hỏi theo các mức độ: Nhận biết – Thông hiểu – Vận dụng
- Học nhanh với 10K Flashcard Tiếng Anh theo bộ sách và chủ đề
- Đầy đủ: Mầm non – Phổ thông (K12) – Đại học – Người đi làm
- Tải toàn bộ tài liệu trên TaiLieu.VN
- Loại bỏ quảng cáo để tăng khả năng tập trung ôn luyện
- Tặng 15 ngày khi đăng ký gói 3 tháng, 30 ngày với gói 6 tháng và 60 ngày với gói 12 tháng.
77.000 đ/ tháng