Question

Mô tả nguyên lý thiết kế SOLID và áp dụng nó trong lập trình C++ thông qua một ví dụ cụ thể.

Answer 1

Nguyên lý thiết kế SOLID là một tập hợp năm nguyên tắc giúp lập trình viên viết mã dễ bảo trì và mở rộng. Các nguyên tắc này bao gồm:

1. S - Single Responsibility Principle (SRP): Mỗi lớp chỉ nên có một trách nhiệm duy nhất.
2. O - Open/Closed Principle (OCP): Lớp phải được mở để mở rộng nhưng đóng để sửa đổi.
3. L - Liskov Substitution Principle (LSP): Các đối tượng của lớp con phải có thể thay thế cho lớp cha mà không làm hỏng chương trình.
4. I - Interface Segregation Principle (ISP): Không nên buộc một lớp phải triển khai các giao diện mà nó không sử dụng.
5. D - Dependency Inversion Principle (DIP): Các module cấp cao không nên phụ thuộc vào module cấp thấp; cả hai đều nên phụ thuộc vào các giao diện.

### Ví dụ áp dụng trong C++:
Giả sử chúng ta xây dựng một ứng dụng quản lý động vật.

1. **Single Responsibility Principle**:
```cpp
class Dog {
public:
    void bark() { /* code to make the dog bark */ }
};

class Cat {
public:
    void meow() { /* code to make the cat meow */ }
};
```
Mỗi lớp chỉ có một trách nhiệm.

2. **Open/Closed Principle**:
```cpp
class Animal {
public:
    virtual void sound() = 0; // Giao diện trừu tượng
};

class Dog : public Animal {
public:
    void sound() override { /* dog sound */ }
};

class Cat : public Animal {
public:
    void sound() override { /* cat sound */ }
};
```
Bạn có thể thêm động vật mới mà không cần sửa đổi lớp Animal.

3. **Liskov Substitution Principle**:
```cpp
void makeSound(Animal* animal) {
    animal->sound(); // Có thể thay thế Dog hoặc Cat mà không gây lỗi
}
```

4. **Interface Segregation Principle**:
```cpp
class IAnimal {
public:
    virtual void eat() = 0;
};

class Dog : public IAnimal {
public:
    void eat() override { /* dog eating behavior */ }
};
```
Không ép buộc động vật phải thực hiện những hành vi không liên quan.