装饰者模式

装饰者模式

装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许在不改变现有对象结构的情况下，动态地向对象添加额外的行为。

装饰者模式的主要目标是通过对对象的包装来扩展其功能。它通过创建一个装饰者类，该类包装了原始对象，并在原始对象的基础上添加新的行为或功能。这样，在不改变原始对象结构或代码的情况下，可以根据需要动态地添加或修改对象的行为。

装饰者模式中的关键角色有：

• 抽象组件（Component）：定义了被装饰者和装饰者之间的共同接口，可以是一个抽象类或接口。
• 具体组件（Concrete Component）：实现了抽象组件的方法，并提供了被包装或装饰的对象。
• 抽象装饰者（Decorator）：继承自抽象组件，包含了一个抽象组件的引用，并定义了对其进行装饰的方法。
• 具体装饰者（Concrete Decorator）：继承自抽象装饰者，实现了对抽象组件的装饰，可以在装饰者的方法中调用父类的方法，并添加新的行为。

装饰者模式的操作步骤如下：

• 定义抽象组件类或接口，其中包含被装饰者和装饰者共同的方法。
• 创建具体组件类，实现抽象组件的方法，提供被装饰或包装的对象。
• 定义抽象装饰者类，继承自抽象组件类或接口，并包含一个抽象组件的引用。
• 创建具体装饰者类，继承自抽象装饰者类，实现对抽象组件的装饰。

在客户端代码中，通过创建具体组件类的对象，并依次用具体装饰者对象进行装饰，以实现对组件的功能扩展或修改。
下面是一个使用C++语言实现的装饰者模式示例代码：

#include 
#include 

// 抽象组件
class Component {
public:
    virtual std::string operation() = 0;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    std::string operation() override {
        return "ConcreteComponent";
    }
};

// 抽象装饰器
class Decorator : public Component {
private:
    Component* component;

public:
    Decorator(Component* component) {
        this->component = component;
    }

    std::string operation() override {
        return component->operation();
    }
};

// 具体装饰器
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component* component) : Decorator(component) {
    }

    std::string operation() override {
        return "ConcreteDecoratorA(" + Decorator::operation() + ")";
    }
};

class ConcreteDecoratorB : public Decorator {
public:
    ConcreteDecoratorB(Component* component) : Decorator(component) {
    }

    std::string operation() override {
        return "ConcreteDecoratorB(" + Decorator::operation() + ")";
    }
};

// 客户端代码
int main() {
    Component* component = new ConcreteComponent();
    Component* decoratorA = new ConcreteDecoratorA(component);
    Component* decoratorB = new ConcreteDecoratorB(decoratorA);

    std::cout << decoratorB->operation() << std::endl;

    delete decoratorB;
    delete decoratorA;
    delete component;

    return 0;
}

在上述代码中，我们有一个抽象组件类 Component，其中定义了一个纯虚函数 operation，代表组件的操作。接着，我们有一个具体组件类 ConcreteComponent，它是抽象组件的实现。
然后，我们定义了一个抽象装饰器类 Decorator，它继承自抽象组件，并持有一个抽象组件对象。在抽象装饰器的 operation 函数中，我们调用持有的抽象组件对象的 operation 函数。
最后，我们有两个具体装饰器类 ConcreteDecoratorA 和 ConcreteDecoratorB，它们分别扩展了抽象装饰器的功能。在具体装饰器的 operation 函数中，我们先调用父类的 operation 函数，然后在结果中添加特定的装饰标识。
在客户端代码中，我们实例化了具体组件的对象，并通过多层装饰，添加了不同的功能。最后，我们调用最外层装饰器的 operation 函数，并输出结果。
运行该示例，会输出 “ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent))”，即装饰器动态地扩展了具体组件的功能。