نمط المزين

جزء من قسم Object Oriented Programming في رحلة C++ على Coddy — الدرس 98 من 104.

يسمح لك نمط المزين (Decorator pattern) بإضافة سلوكيات جديدة إلى الكائنات ديناميكيًا عن طريق تغليفها في كائنات خاصة تسمى المزينين (decorators). على عكس الوراثة (inheritance)، التي تضيف السلوك في وقت التجميع (compile time)، تتيح لك المزينيات (decorators) توسيع الوظائف في وقت التشغيل (runtime) دون تعديل الفئة (class) الأصلية.

يعمل هذا النمط من خلال جعل كل من الكائن الأصلي والمزخرفات (decorators) ينفذون نفس الواجهة (interface). يحتفظ كل مزخرف بمرجع لمكون ويضيف سلوكه الخاص قبل أو بعد التفويض إلى الكائن المغلف:

#include <iostream>
#include <memory>

// واجهة المكون
class Coffee {
public:
    virtual std::string getDescription() const = 0;
    virtual double getCost() const = 0;
    virtual ~Coffee() = default;
};

// مكون ملموس
class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override { return "Coffee"; }
    double getCost() const override { return 2.0; }
};

// المزين الأساسي
class CoffeeDecorator : public Coffee {
protected:
    std::unique_ptr<Coffee> coffee;
public:
    CoffeeDecorator(std::unique_ptr<Coffee> c) : coffee(std::move(c)) {}
};

// المزينون الملموسون
class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(std::unique_ptr<Coffee> c) : CoffeeDecorator(std::move(c)) {}
    std::string getDescription() const override {
        return coffee->getDescription() + ", Milk";
    }
    double getCost() const override { return coffee->getCost() + 0.5; }
};

class SugarDecorator : public CoffeeDecorator {
public:
    SugarDecorator(std::unique_ptr<Coffee> c) : CoffeeDecorator(std::move(c)) {}
    std::string getDescription() const override {
        return coffee->getDescription() + ", Sugar";
    }
    double getCost() const override { return coffee->getCost() + 0.2; }
};

يمكن تكديس المزخرفات (Decorators) - حيث يغلف كل منها السابق، مما يبني الوظائف طبقة تلو الأخرى:

int main() {
    std::unique_ptr<Coffee> order = std::make_unique<SimpleCoffee>();
    order = std::make_unique<MilkDecorator>(std::move(order));
    order = std::make_unique<SugarDecorator>(std::move(order));
    
    std::cout << order->getDescription() << ": $" << order->getCost();
    // المخرجات: Coffee, Milk, Sugar: $2.7
}

استخدم نمط Decorator عندما تحتاج إلى إضافة مسؤوليات إلى الكائنات ديناميكياً دون التأثير على الكائنات الأخرى، أو عندما يؤدي توسيع الوظائف من خلال الوراثة الفرعية (subclassing) إلى تضخم هائل في عدد الفئات.

التحدي

سهل

لنقم ببناء نظام طلب بيتزا (Pizza Order System) باستخدام نمط المزيّن (Decorator pattern). ستقوم بإنشاء نظام مرن حيث يمكن للعملاء البدء ببيتزا أساسية وإضافة إضافات متنوعة — كل إضافة تغلف الطلب السابق وتضيف تكلفتها ووصفها الخاص. هذه حالة استخدام مثالية للمزيّنات: يمكن تكديس الإضافات بأي مزيج دون إنشاء عدد هائل من الفئات الفرعية.

ستقوم بتنظيم الكود الخاص بك عبر ثلاثة ملفات:

Pizza.h: تحديد واجهة المكون (component interface) وفئة البيتزا الأساسية.
قم بإنشاء فئة Pizza مجردة (abstract) مع دوال افتراضية بحتة (pure virtual methods) وهي getDescription() (تعيد سلسلة نصية) و getCost() (تعيد رقماً عشرياً double)، بالإضافة إلى مدمر افتراضي (virtual destructor).

ثم قم بإنشاء فئة PlainPizza ملموسة تمثل البيتزا الأساسية. يجب أن تعيد "Pizza" كوصف لها ولها تكلفة أساسية قدرها 8.0.
ToppingDecorator.h: بناء الفئة الأساسية للمزيّن ومزيّنات الإضافات الملموسة.
قم بإنشاء فئة ToppingDecorator ترث من Pizza وتحتوي على std::unique_ptr<Pizza> للمكون المغلف. يعمل هذا كأساس لجميع مزيّنات الإضافات.

قم بتنفيذ ثلاثة مزيّنات إضافات ملموسة:
- CheeseTopping — يضيف ", Cheese" إلى الوصف و 1.5 إلى التكلفة
- PepperoniTopping — يضيف ", Pepperoni" إلى الوصف و 2.0 إلى التكلفة
- MushroomTopping — يضيف ", Mushrooms" إلى الوصف و 1.0 إلى التكلفة
يجب على كل مزيّن تفويض العمل للبيتزا المغلفة ثم إضافة مساهمته الخاصة.
main.cpp: إنشاء طلب بيتزا مخصص بناءً على مدخلات المستخدم.
اقرأ ثلاثة مدخلات (كل منها سيكون yes أو no):
1. إضافة جبنة؟
2. إضافة بيبيروني؟
3. إضافة فطر؟
ابدأ بـ PlainPizza، ثم غلفها بمزيّنات الإضافات المناسبة بناءً على المدخلات (بالترتيب: الجبن، البيبيروني، الفطر). أخيراً، اطبع تفاصيل الطلب بهذا التنسيق:
```
Order: [description]
Total: $[cost]
```

على سبيل المثال، مع المدخلات yes، yes، no:

Order: Pizza, Cheese, Pepperoni
Total: $11.5

مع المدخلات yes، no، yes:

Order: Pizza, Cheese, Mushrooms
Total: $10.5

مع المدخلات no، no، no:

Order: Pizza
Total: $8

مع المدخلات yes، yes، yes:

Order: Pizza, Cheese, Pepperoni, Mushrooms
Total: $12.5

لاحظ كيف يغلف كل مزيّن المزيّن السابق، مما يبني كلاً من الوصف والتكلفة طبقة تلو الأخرى. يمكنك بسهولة إضافة إضافات جديدة عن طريق إنشاء فئات مزيّن جديدة دون تعديل كود البيتزا أو الإضافات الحالي — وهذا هو جمال نمط Decorator.

ورقة مرجعية

يسمح لك نمط المزين (Decorator pattern) بإضافة سلوكيات جديدة إلى الكائنات ديناميكيًا عن طريق تغليفها في كائنات خاصة تسمى المزينين (decorators). على عكس الوراثة، التي تضيف السلوك في وقت التجميع (compile time)، تتيح لك المزينات توسيع الوظائف في وقت التشغيل (runtime) دون تعديل الفئة الأصلية.

يعمل النمط من خلال جعل كل من الكائن الأصلي والمزينات ينفذون نفس الواجهة (interface). يحتفظ كل مزين بمرجع لمكون ويضيف سلوكه الخاص قبل أو بعد التفويض إلى الكائن المغلف.

الهيكل

واجهة المكون (Component interface): تحدد الواجهة المشتركة لكل من المكونات الملموسة والمزينات.

class Coffee {
public:
    virtual std::string getDescription() const = 0;
    virtual double getCost() const = 0;
    virtual ~Coffee() = default;
};

المكون الملموس (Concrete component): الكائن الأساسي الذي يمكن تزيينه.

class SimpleCoffee : public Coffee {
public:
    std::string getDescription() const override { return "Coffee"; }
    double getCost() const override { return 2.0; }
};

المزين الأساسي (Base decorator): يحتفظ بمرجع لمكون وينفذ نفس الواجهة.

class CoffeeDecorator : public Coffee {
protected:
    std::unique_ptr<Coffee> coffee;
public:
    CoffeeDecorator(std::unique_ptr<Coffee> c) : coffee(std::move(c)) {}
};

المزينات الملموسة (Concrete decorators): تضيف سلوكيات محددة من خلال التفويض إلى الكائن المغلف وإضافة وظائفها الخاصة.

class MilkDecorator : public CoffeeDecorator {
public:
    MilkDecorator(std::unique_ptr<Coffee> c) : CoffeeDecorator(std::move(c)) {}
    std::string getDescription() const override {
        return coffee->getDescription() + ", Milk";
    }
    double getCost() const override { return coffee->getCost() + 0.5; }
};

تكديس المزينات

يمكن تكديس المزينات - حيث يغلف كل واحد منها المزين السابق، مما يؤدي إلى بناء الوظائف طبقة تلو الأخرى:

std::unique_ptr<Coffee> order = std::make_unique<SimpleCoffee>();
order = std::make_unique<MilkDecorator>(std::move(order));
order = std::make_unique<SugarDecorator>(std::move(order));

std::cout << order->getDescription() << ": $" << order->getCost();
// Output: Coffee, Milk, Sugar: $2.7

متى يُستخدم

استخدم نمط المزين عندما تحتاج إلى إضافة مسؤوليات إلى الكائنات ديناميكيًا دون التأثير على الكائنات الأخرى، أو عندما يؤدي توسيع الوظائف من خلال التوريث الفرعي (subclassing) إلى انفجار في عدد الفئات.

جرّب بنفسك

#include <iostream>
#include <string>
#include <memory>
#include "Pizza.h"
#include "ToppingDecorator.h"

using namespace std;

int main() {
    // قراءة ثلاثة مدخلات (نعم أو لا)
    string addCheese, addPepperoni, addMushrooms;
    cin >> addCheese;
    cin >> addPepperoni;
    cin >> addMushrooms;
    
    // TODO: ابدأ بـ PlainPizza باستخدام std::unique_ptr
    
    // TODO: إذا كانت addCheese هي "yes"، قم بتغليف البيتزا بـ CheeseTopping
    
    // TODO: إذا كانت addPepperoni هي "yes"، قم بتغليف البيتزا بـ PepperoniTopping
    
    // TODO: إذا كانت addMushrooms هي "yes"، قم بتغليف البيتزا بـ MushroomTopping
    
    // TODO: اطبع الطلب بالتنسيق التالي:
    // Order: [الوصف]
    // Total: $[التكلفة]
    
    return 0;
}