Để khai báo một mảng động cho phép nhập một chuỗi văn bản ta dùng câu lệnh nào sau đây?

Đoạn mã có một số lỗi cú pháp và logic cần được chỉ ra:

* Dòng 1: Tên lớp `Lopl` có lẽ là một lỗi đánh máy. Nó nên là `Lop1` để phù hợp với việc sử dụng ở dòng 15. Tuy nhiên, lỗi chính tả này một mình nó không gây ra lỗi biên dịch nếu không có tham chiếu đến `Lop1` ở những nơi khác.
* Dòng 5 và 11: `friend voidNhap();` và `friend void Nhap( );`. Ở đây, hàm friend được khai báo là `Nhap` trong `Lop1` và `Nhap` trong `Lop2`. Các hàm friend được khai báo nhưng chưa được định nghĩa. Tên hàm có thể gây nhầm lẫn với `nhap()` ở dòng 13. Đây không phải là lỗi biên dịch, nhưng là một vấn đề thiết kế có thể gây nhầm lẫn.
* Dòng 13: `void nhap()` định nghĩa một hàm toàn cục. Trong hàm này, bạn cố gắng tạo các đối tượng `obj1` thuộc lớp `Lop 1` (lại là lỗi chính tả, phải là `Lop1`) và `obj2` thuộc lớp `Lop2`.
* Dòng 15: `Lop 1 obj 1; Lop2 obj 2;`. Ở đây có một lỗi chính tả lớn: `Lop 1` phải là `Lop1`. Nếu không sửa lỗi chính tả này, chương trình sẽ không biên dịch được.
* Dòng 16 và 17: `cout«"\n\t Nhap a ="; cin»objl.a;` và `cout«"\n\t Nhap x cin»obj2.x;`. Toán tử `«` và `»` bị ngược. Phải là `cout <<` và `cin >>`.

Như vậy, lỗi tập trung ở dòng 16 và 17 do sử dụng sai toán tử nhập xuất `<<` và `>>` đồng thời có lỗi chính tả ở dòng 15.

Đề bài yêu cầu khai báo mảng số thực động. Điều này có nghĩa là kích thước mảng được xác định trong quá trình chạy chương trình (run-time) chứ không phải tại thời điểm biên dịch (compile-time).

* Đáp án 1: `float *M; int n; cout<<"\n\t Nhập số phần tử mảng ";cin>>n; A M = new float [n]` Đây là cách khai báo đúng. `float *M` khai báo một con trỏ tới kiểu float. Sau đó, sử dụng `new float[n]` để cấp phát bộ nhớ động cho mảng `M` có `n` phần tử kiểu float. Tuy nhiên, có một lỗi nhỏ là `A M = new float [n]` phải là `M = new float[n]`. Bỏ qua lỗi nhỏ này, đây là đáp án đúng về mặt ý tưởng.
* Đáp án 2: `int n; cout<<"\n\t Nhap số phần tử mảng: ";cin>>n; float M[n]` Cách khai báo này sử dụng Variable Length Array (VLA), được hỗ trợ trong một số trình biên dịch C++ nhưng không phải là một phần của chuẩn C++ chính thức (từ C++11 trở đi). Vì vậy, nó không phải là một cách khai báo mảng động chuẩn và có thể gây ra vấn đề tương thích. Quan trọng hơn, VLA được cấp phát trên stack, vốn có kích thước giới hạn, nên có thể gây ra tràn stack nếu `n` quá lớn.
* Đáp án 3: `intn; floatM[n]` Tương tự như đáp án 2, đây là VLA và không phải là cách khai báo mảng động chuẩn.
* Đáp án 4: `float M[int n]` Cách khai báo này sai cú pháp. Số phần tử của mảng phải là một hằng số hoặc biểu thức hằng số tại thời điểm biên dịch, hoặc sử dụng cấp phát động.

Đoạn mã C++ có một số lỗi cần được xem xét:

1. Lỗi chính tại dòng 16 và 17: Các biến `a` và `x` được sử dụng trong `cin >> a;` và `cin >> x;` không thuộc phạm vi của hàm `nhap()`. Trong hàm `nhap()`, `objl` (kiểu `Lopl`) và `obj2` (kiểu `Lop2`) được tạo ra, nhưng các thành viên dữ liệu `a` của `objl` và `x` của `obj2` là `private`. Hàm `nhap()` không phải là `friend` của cả hai lớp, do đó nó không thể truy cập trực tiếp các thành viên `private` này. Ngay cả khi các biến `a` và `x` được khai báo trong hàm `nhap`, thì chúng vẫn là các biến cục bộ khác với các thành viên dữ liệu `a` và `x` trong các đối tượng `objl` và `obj2`. Để khắc phục, cần làm cho hàm `nhap()` trở thành `friend` của cả hai lớp, hoặc cung cấp các hàm `public` để truy cập và sửa đổi các thành viên `private` này. Tuy nhiên, theo đoạn code được cung cấp, lỗi truy cập trực tiếp các biến thành viên private là nguyên nhân chính.

2. Lỗi khác: Tên lớp `Lopl` nên là `Lop1` (chữ `i` thường thay vì `l`). Tương tự, `cout«` nên là `cout <<`.

Như vậy, lỗi tập trung ở dòng 16 và 17 do cố gắng truy cập trực tiếp các thành viên private từ bên ngoài lớp mà không có quyền truy cập (không phải là hàm friend hoặc thông qua các phương thức public).

Trong đoạn mã C++ đã cho, lớp `B` kế thừa từ lớp `A` theo chế độ `public`. Điều này có nghĩa là tất cả các thành viên `public` và `protected` của lớp `A` đều trở thành thành viên `public` của lớp `B`. Vì tất cả các biến thành viên `a`, `b`, `F1`, và `F2` của lớp `A` đều không được khai báo là `private`, chúng mặc định là `public` (nếu được khai báo trong struct) hoặc cần phải xem xét phạm vi truy cập nếu khai báo trong class. Trong trường hợp này, do lớp A được khai báo bằng từ khóa class, nên mặc định các biến thành viên là private. Tuy nhiên, vì lớp B kế thừa từ lớp A theo kiểu public nên vẫn có thể truy cập các biến a, b, F1, F2 thông qua các phương thức public hoặc protected của lớp A. Tuy nhiên, nếu câu hỏi hỏi "B sử dụng được các biến thành viên nào của A", thì phải hiểu là B kế thừa và có thể sử dụng trực tiếp (như là biến thành viên của B). Vì vậy, lớp B sẽ được kế thừa tất cả các biến thành viên `a`, `b`, `F1`, và `F2` từ lớp `A`.

Từ khoá `protected` trong lập trình hướng đối tượng (OOP) được sử dụng để khai báo các thành viên (biến, phương thức) của một lớp có thể được truy cập từ bên trong lớp đó, từ các lớp con (lớp kế thừa) và từ các lớp trong cùng một package (nếu ngôn ngữ lập trình có khái niệm package).

* Phương án 1: Sai. `protected` cho phép thừa kế, nhưng không chỉ định rằng các thành viên chỉ được thừa kế.
* Phương án 2: Đúng. `protected` dùng để khai báo các thành viên được bảo vệ, có nghĩa là chúng có quyền truy cập hạn chế so với `public` nhưng rộng hơn `private`.
* Phương án 3: Sai. `private` mới là từ khóa để khai báo các thành viên dùng riêng.
* Phương án 4: Sai. `protected` không có nghĩa là các thành viên sẽ được dùng chung (như `public`) mà có phạm vi truy cập hạn chế hơn.

Vậy, đáp án đúng nhất là phương án 2.