Mixin qua CRTP

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

Mẫu thiết kế khuôn mẫu đệ quy kỳ lạ (Curiously Recurring Template Pattern, CRTP) là kỹ thuật trong đó một lớp kế thừa từ lớp cơ sở dạng khuôn mẫu và truyền chính nó làm đối số khuôn mẫu. Kỹ thuật này cho phép đa hình tại thời điểm biên dịch và giúp lớp cơ sở truy cập các thành viên của lớp dẫn xuất mà không cần hàm ảo.

Cấu trúc CRTP cơ bản trông như sau:

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class MyClass : public Base<MyClass> {
public:
    void implementation() {
        std::cout << "MyClass implementation\n";
    }
};

CRTP đặc biệt hữu ích khi tạo mixins, tức là chức năng có thể tái sử dụng và được «trộn vào» các lớp. Khác với kế thừa truyền thống, mixin bổ sung khả năng mà không tạo ra hệ phân cấp sâu:

template <typename Derived>
class Printable {
public:
    void print() const {
        const Derived& self = static_cast<const Derived&>(*this);
        std::cout << self.toString() << "\n";
    }
};

class Person : public Printable<Person> {
    std::string name;
public:
    Person(const std::string& n) : name(n) {}
    std::string toString() const { return "Person: " + name; }
};

// Cách sử dụng:
Person p("Alice");
p.print();  // Đầu ra: Person: Alice

Ưu điểm chính là mọi lời gọi phương thức (method) đều được phân giải tại thời điểm biên dịch, nhờ đó loại bỏ phần chi phí phát sinh từ hàm ảo. Bạn có thể kết hợp nhiều mixin CRTP để ghép các chức năng, tạo nên một lựa chọn linh hoạt thay cho đa hình thời gian chạy khi các kiểu đã được xác định tại thời điểm biên dịch.

Thử thách

Dễ

Hãy xây dựng một hệ thống ghi nhật ký dùng các mixin CRTP để bổ sung chức năng có thể tái sử dụng cho nhiều lớp khác nhau mà không phải chịu chi phí của hàm ảo. Bạn sẽ tạo hai mixin có thể được kết hợp vào bất kỳ lớp nào: một mixin dùng để đếm số instance và một mixin dùng để tạo biểu diễn dạng chuỗi.

Bạn sẽ tổ chức code trong ba tệp:

Mixins.h: Định nghĩa hai mẫu mixin CRTP cung cấp chức năng có thể tái sử dụng.
Tạo một mẫu mixin Countable để theo dõi số instance của lớp dẫn xuất. Mixin này cần có một bộ đếm tĩnh, tăng lên trong hàm khởi tạo và giảm xuống trong hàm hủy. Cung cấp phương thức tĩnh getCount() để trả về số đếm hiện tại.

Tạo một mẫu mixin Describable cung cấp phương thức describe(). Phương thức này cần dùng static_cast để truy cập lớp dẫn xuất và gọi phương thức getDescription() của lớp đó, sau đó in kết quả kèm theo một ký tự xuống dòng.

Hãy nhớ rằng các mixin CRTP dùng static_cast<Derived*>(this) để truy cập các thành viên của lớp dẫn xuất tại thời điểm biên dịch.
Entities.h: Định nghĩa hai lớp thực thể kế thừa từ cả hai mixin.
Tạo lớp Player kế thừa từ cả Countable<Player> và Describable<Player>. Lớp này cần lưu tên và cấp độ, đồng thời cung cấp phương thức getDescription() trả về chuỗi theo định dạng: Player: [name] (Level [level])

Tạo lớp Enemy cũng kế thừa từ cả hai mixin. Lớp này cần lưu loại và máu, đồng thời cung cấp phương thức getDescription() trả về: Enemy: [type] with [health] HP

Đừng quên khởi tạo bộ đếm tĩnh cho mỗi lớp.
main.cpp: Đọc bốn đầu vào, mỗi đầu vào trên một dòng riêng:
1. Tên Player (chuỗi)
2. Cấp độ Player (số nguyên)
3. Loại Enemy (chuỗi)
4. Máu của Enemy (số nguyên)
Tạo một Player và một Enemy với các giá trị đã cho. Sau đó, minh họa các mixin:
1. In Player count: [count] bằng phương thức tĩnh getCount()
2. In Enemy count: [count]
3. Gọi describe() trên Player
4. Gọi describe() trên Enemy
5. Tạo Player thứ hai với tên "Guest" và cấp độ 1
6. In lại Player count: [count] để hiển thị số đếm đã cập nhật
7. Gọi describe() trên Player thứ hai

Ví dụ, với các đầu vào Hero, 10, Dragon và 500:

Player count: 1
Enemy count: 1
Player: Hero (Level 10)
Enemy: Dragon with 500 HP
Player count: 2
Player: Guest (Level 1)

Thử thách này minh họa cách các mixin CRTP bổ sung chức năng đếm và mô tả cho những lớp không liên quan mà không dùng hàm ảo. Cả Player và Enemy đều có những khả năng giống nhau nhờ kế thừa từ cùng các mẫu mixin, nhưng mỗi lớp duy trì bộ đếm instance riêng vì mẫu được khởi tạo với các kiểu khác nhau.

Tự làm thử

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

using namespace std;

int main() {
    // Đọc dữ liệu đầu vào
    string playerName;
    int playerLevel;
    string enemyType;
    int enemyHealth;
    
    cin >> playerName;
    cin >> playerLevel;
    cin >> enemyType;
    cin >> enemyHealth;
    
    // TODO: Tạo một Player với tên và cấp độ đã cho
    
    // TODO: Tạo một Enemy với loại và lượng máu đã cho
    
    // TODO: In ra "Player count: [count]" bằng Player::getCount()
    
    // TODO: In ra "Enemy count: [count]" bằng Enemy::getCount()
    
    // TODO: Gọi describe() cho người chơi
    
    // TODO: Gọi describe() cho kẻ địch
    
    // TODO: Tạo người chơi thứ hai có tên "Guest" và cấp độ 1
    
    // TODO: In lại "Player count: [count]"
    
    // TODO: Gọi describe() cho người chơi thứ hai
    
    return 0;
}