Kết hợp so với kế thừa

Thuộc phần Lập trình hướng đối tượng trong hành trình C++ của Coddy. Bài học 76 trên 104.

Khi thiết kế mối quan hệ giữa các lớp, bạn có hai lựa chọn chính: kế thừa ("is-a") và kết hợp ("has-a"). Chọn cách tiếp cận phù hợp sẽ ảnh hưởng đáng kể đến tính linh hoạt và khả năng bảo trì của code.

Kế thừa (inheritance) tạo ra mối liên kết chặt chẽ giữa các lớp. Một Car kế thừa từ Vehicle sẽ mãi gắn với mối quan hệ đó:

class Vehicle {
public:
    virtual void start() { std::cout << "Starting vehicle\n"; }
};

class Car : public Vehicle {
public:
    void start() override { std::cout << "Starting car\n"; }
};

Tính hợp thành nhúng các đối tượng làm thành viên, tạo nên mối quan hệ linh hoạt hơn. Một Car có một Engine thay vì là một động cơ:

class Engine {
public:
    void start() { std::cout << "Engine running\n"; }
};

class Car {
private:
    Engine engine;  // Car có một Engine
public:
    void start() { engine.start(); }
};

Ưu điểm chính của cách kết hợp là tính linh hoạt. Bạn có thể dễ dàng thay đổi các thành phần, thay đổi hành vi khi chương trình đang chạy hoặc kết hợp nhiều khả năng mà không bị giới hạn bởi hệ thống phân cấp lớp cứng nhắc. Trong hầu hết trường hợp, thiết kế C++ hiện đại ưu tiên cách kết hợp hơn kế thừa.

Dùng kế thừa (inheritance) khi có mối quan hệ “là một” thực sự và bạn cần tính đa hình. Dùng hợp thành (composition) khi bạn muốn tái sử dụng chức năng hoặc khi mối quan hệ được mô tả chính xác hơn là “có một” hoặc “sử dụng một”.

Thử thách

Dễ

Hãy xây dựng trình mô phỏng hệ thống máy tính để minh họa khi nào nên dùng kết hợp đối tượng (composition) thay vì kế thừa. Bạn sẽ mô hình hóa một máy tính có các thành phần (kết hợp đối tượng) thay vì là một thành phần, qua đó cho thấy kết hợp đối tượng giúp thay thế linh kiện linh hoạt khi chương trình đang chạy.

Bạn sẽ sắp xếp code trong ba tệp:

Components.h: Định nghĩa các thành phần riêng lẻ mà một máy tính có thể bao gồm.
Tạo lớp CPU với std::string model và int cores ở phạm vi private. Cung cấp hàm khởi tạo nhận cả hai giá trị, phương thức process() in ra CPU [model] processing with [cores] cores, và phương thức getModel().

Tạo lớp Memory với int sizeGB ở phạm vi private. Cung cấp hàm khởi tạo, phương thức load() in ra Loading data into [sizeGB]GB RAM, và phương thức getSize().

Tạo lớp Storage với std::string type ở phạm vi private (chẳng hạn "SSD" hoặc "HDD") và int capacityGB. Cung cấp hàm khởi tạo, phương thức read() in ra Reading from [capacityGB]GB [type], và các phương thức lấy giá trị của cả hai thuộc tính.
Computer.h: Định nghĩa lớp Computer dùng cách kết hợp đối tượng để kết hợp các thành phần.
Lớp Computer cần có các đối tượng thành viên ở phạm vi private: một CPU, một Memory và một Storage. Dùng danh sách khởi tạo của hàm khởi tạo để khởi tạo các thành phần này từ các tham số.

Cài đặt các phương thức sau:
- boot(): in ra Booting computer..., sau đó gọi load() trên bộ nhớ, read() trên thiết bị lưu trữ và process() trên CPU, mỗi lệnh trên một dòng riêng
- specs(): in thông số máy tính theo định dạng sau:
```
Computer Specs:
- CPU: [model] ([cores] cores)
- RAM: [size]GB
- Storage: [capacity]GB [type]
```
main.cpp: Đọc sáu đầu vào (mỗi đầu vào trên một dòng riêng):
1. Tên mẫu CPU (chuỗi)
2. Số lõi CPU (số nguyên)
3. Dung lượng bộ nhớ tính bằng GB (số nguyên)
4. Loại thiết bị lưu trữ (chuỗi, ví dụ: "SSD")
5. Dung lượng thiết bị lưu trữ tính bằng GB (số nguyên)
6. Một lệnh: "boot" hoặc "specs"
Tạo các đối tượng thành phần, sau đó tạo một Computer bằng cách kết hợp đối tượng. Tùy theo lệnh, hãy gọi boot() hoặc specs().

Ví dụ, với các đầu vào Intel i7, 8, 16, SSD, 512 và boot:

Booting computer...
Loading data into 16GB RAM
Reading from 512GB SSD
CPU Intel i7 processing with 8 cores

Với các đầu vào AMD Ryzen, 6, 32, HDD, 1000 và specs:

Computer Specs:
- CPU: AMD Ryzen (6 cores)
- RAM: 32GB
- Storage: 1000GB HDD

Lưu ý rằng lớp Computer không kế thừa từ thành phần nào. Nó chứa các thành phần đó. Mối quan hệ “có” này giúp bạn dễ dàng tạo máy tính với các tổ hợp linh kiện khác nhau, hoặc thậm chí thay linh kiện sau này nếu bạn thêm các phương thức setter. Tính linh hoạt này là ưu điểm chính của kết hợp đối tượng so với kế thừa.

Tự làm thử

#include <iostream>
#include <string>
#include "Computer.h"

using namespace std;

int main() {
    // Đọc dữ liệu đầu vào
    string cpuModel;
    getline(cin, cpuModel);  // Tên mẫu CPU (có thể chứa dấu cách)
    
    int cpuCores;
    cin >> cpuCores;  // Số lõi CPU
    
    int memorySize;
    cin >> memorySize;  // Dung lượng bộ nhớ tính bằng GB
    
    string storageType;
    cin >> storageType;  // Loại thiết bị lưu trữ (ví dụ: "SSD")
    
    int storageCapacity;
    cin >> storageCapacity;  // Dung lượng lưu trữ tính bằng GB
    
    string command;
    cin >> command;  // Lệnh: "boot" hoặc "specs"

    // TODO: Tạo các đối tượng thành phần (CPU, Memory, Storage)
    
    // TODO: Tạo một đối tượng Computer bằng cách dùng quan hệ hợp thành
    
    // TODO: Dựa vào lệnh, gọi boot() hoặc specs()

    return 0;
}