Mẫu tổng hợp

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 101 trên 104.

Mẫu Composite pattern cho phép bạn xử lý thống nhất từng đối tượng riêng lẻ và nhóm đối tượng. Mẫu này kết hợp các đối tượng thành cấu trúc cây, trong đó cả phần tử đơn lẻ lẫn vùng chứa phần tử đều dùng chung một giao diện. Cách này rất phù hợp để biểu diễn các cấu trúc phân cấp như hệ thống tệp, sơ đồ tổ chức hoặc thành phần giao diện người dùng.

Mẫu này có ba phần chính: giao diện Component định nghĩa các thao tác chung, các lớp Leaf đại diện cho từng đối tượng riêng lẻ và các lớp Composite chứa các đối tượng con rồi ủy quyền thao tác cho chúng:

#include <iostream>
#include <memory>
#include <vector>
#include <string>

// Giao diện thành phần (component)
class FileSystemItem {
public:
    virtual void display(int indent = 0) const = 0;
    virtual int getSize() const = 0;
    virtual ~FileSystemItem() = default;
};

// Thành phần lá (leaf): đại diện cho từng tệp
class File : public FileSystemItem {
    std::string name;
    int size;
public:
    File(const std::string& n, int s) : name(n), size(s) {}
    
    void display(int indent = 0) const override {
        std::cout << std::string(indent, ' ') << name 
                  << " (" << size << " KB)\n";
    }
    int getSize() const override { return size; }
};

// Thành phần tổng hợp (composite): chứa các thành phần khác
class Folder : public FileSystemItem {
    std::string name;
    std::vector<std::shared_ptr<FileSystemItem>> children;
public:
    Folder(const std::string& n) : name(n) {}
    
    void add(std::shared_ptr<FileSystemItem> item) {
        children.push_back(item);
    }
    
    void display(int indent = 0) const override {
        std::cout << std::string(indent, ' ') << "[" << name << "]\n";
        for (const auto& child : children) {
            child->display(indent + 2);
        }
    }
    
    int getSize() const override {
        int total = 0;
        for (const auto& child : children) {
            total += child->getSize();
        }
        return total;
    }
};

Đối tượng kết hợp Folder lưu các đối tượng con và thực hiện các thao tác bằng cách lặp qua chúng. Khi bạn gọi getSize() trên một thư mục, hàm này sẽ tính đệ quy tổng kích thước của tất cả mục bên trong. Code phía client không cần biết nó đang làm việc với tệp hay thư mục, vì cả hai đều phản hồi theo cùng một giao diện.

Dùng Composite khi bạn cần biểu diễn cấu trúc phân cấp bộ phận và tổng thể, đồng thời muốn các ứng dụng khách xử lý thống nhất đối tượng riêng lẻ và các tổ hợp.

Thử thách

Dễ

Hãy xây dựng hệ thống Sơ đồ tổ chức bằng mẫu Composite. Bạn sẽ tạo một hệ thống phân cấp, trong đó cả nhân viên riêng lẻ và phòng ban (có thể chứa nhân viên hoặc phòng ban nhỏ hơn) đều được xử lý thống nhất. Cách này phản ánh cơ cấu của các công ty trong thực tế: phòng ban chứa nhân viên và các phòng ban khác, tạo thành cấu trúc cây.

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

OrgComponent.h: Định nghĩa giao diện thành phần mà cả nhân viên lẫn phòng ban sẽ triển khai.
Tạo lớp trừu tượng OrgComponent với:
- getName(): trả về tên của thành phần
- getSalary(): trả về tổng lương (với nhân viên là lương của họ; với phòng ban là tổng lương của tất cả thành viên)
- display(int indent = 0): hiển thị thành phần với mức thụt lề phù hợp
Thêm hàm hủy ảo.
Organization.h: Triển khai các lớp lá và lớp tổ hợp.
Tạo lớp Employee (lớp lá) lưu tên và lương. Phương thức display() của lớp này sẽ in thông tin nhân viên theo định dạng:
```
[indent spaces]- [name] ($[salary])
```
Tạo lớp Department (lớp tổ hợp) lưu tên và tập hợp các thành phần con thuộc kiểu OrgComponent, sử dụng std::shared_ptr. Triển khai:
- add(std::shared_ptr<OrgComponent> component): thêm một thành phần con vào phòng ban
- getSalary(): tính đệ quy tổng lương của tất cả thành viên
- display(): in tên phòng ban trong dấu ngoặc vuông, sau đó hiển thị tất cả thành phần con với mức thụt lề tăng thêm (thêm 2 dấu cách cho mỗi cấp)
Định dạng hiển thị của phòng ban là:
```
[indent spaces][Department Name]
  [children displayed with indent + 2]
```
main.cpp: Xây dựng và hiển thị cơ cấu tổ chức.
Đọc bốn đầu vào:
1. Tên công ty (chuỗi)
2. Tên phòng ban (chuỗi)
3. Tên và lương của nhân viên thứ nhất (định dạng: name,salary)
4. Tên và lương của nhân viên thứ hai (định dạng: name,salary)
Xây dựng cơ cấu sau: Tạo một công ty (phòng ban cấp cao nhất), thêm một phòng ban nhỏ vào đó, rồi thêm cả hai nhân viên vào phòng ban nhỏ này. Sau đó, hiển thị toàn bộ cơ cấu tổ chức và in tổng lương của công ty.

Sau khi hiển thị cơ cấu, in:
```
Total Salary: $[amount]
```

Ví dụ, với các đầu vào TechCorp, Engineering, Alice,75000 và Bob,65000:

[TechCorp]
  [Engineering]
    - Alice ($75000)
    - Bob ($65000)
Total Salary: $140000

Với các đầu vào StartupInc, Development, Carol,80000 và Dave,70000:

[StartupInc]
  [Development]
    - Carol ($80000)
    - Dave ($70000)
Total Salary: $150000

Lưu ý rằng getSalary() hoạt động thống nhất dù được gọi trên nhân viên hay phòng ban: phòng ban tự động cộng gộp lương của tất cả thành viên. Code phía gọi không cần phân biệt giữa nhân viên riêng lẻ và toàn bộ phòng ban khi tính tổng hoặc hiển thị hệ thống phân cấp.

Tự làm thử

#include <iostream>
#include <string>
#include <memory>
#include <sstream>
#include "Organization.h"

int main() {
    // Đọc dữ liệu đầu vào
    std::string companyName;
    std::string departmentName;
    std::string employee1Input;
    std::string employee2Input;
    
    std::getline(std::cin, companyName);
    std::getline(std::cin, departmentName);
    std::getline(std::cin, employee1Input);
    std::getline(std::cin, employee2Input);
    
    // Hàm lambda hỗ trợ phân tích định dạng "name,salary"
    auto parseEmployee = [](const std::string& input) -> std::pair<std::string, int> {
        size_t commaPos = input.find(',');
        std::string name = input.substr(0, commaPos);
        int salary = std::stoi(input.substr(commaPos + 1));
        return {name, salary};
    };
    
    auto [name1, salary1] = parseEmployee(employee1Input);
    auto [name2, salary2] = parseEmployee(employee2Input);
    
    // TODO: Tạo công ty dưới dạng Department cấp cao nhất
    
    // TODO: Tạo một phòng ban con
    
    // TODO: Tạo hai đối tượng Employee từ dữ liệu đã phân tích
    
    // TODO: Thêm nhân viên vào phòng ban con
    
    // TODO: Thêm phòng ban con vào công ty
    
    // TODO: Hiển thị toàn bộ cấu trúc tổ chức
    
    // TODO: In ra tổng tiền lương theo định dạng: Total Salary: $[amount]
    
    return 0;
}