设计模式（八）--装饰模式

装饰模式（Decorator Pattern）是一种结构型设计模式，它允许在不修改现有类的基础上动态地扩展一个对象的功能。装饰模式通过继承来实现，它提供了一个灵活的替代方案来代替使用子类进行扩展。装饰模式通常用于在运行时动态地向对象添加职责或行为，而不是通过继承来静态地扩展类的功能。

装饰模式的关键组成部分

1. 组件接口（Component）：定义了真实对象的基本行为。
2. 具体组件（Concrete Component）：实现了组件接口，并提供了基本的行为。
3. 装饰器（Decorator）：实现了组件接口，并包含具体组件的引用，可以在原有行为的基础上增加新的行为。
4. 具体装饰器（Concrete Decorators）：实现了装饰器接口，并提供了增强的行为。

装饰模式的应用场景

装饰模式适用于以下情况：

• 动态地给一个对象添加职责。
• 需要扩展一个类的功能，但不想创建太多的子类。
• 需要在运行时根据条件添加功能。

装饰模式的实现步骤

1. 定义组件接口。
2. 实现具体组件类。
3. 实现装饰器类，并包含具体组件的引用。
4. 实现具体装饰器类，并提供增强的行为。

装饰模式的示例

假设我们正在设计一个文本处理系统，可以动态地为文本添加不同的格式（如加粗、斜体等）。

步骤1：定义组件接口

c

深色版本

1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4
5// 组件接口
6typedef struct Component {
7    void (*print)(const char *text);
8} Component;
9
10void printText(Component *component, const char *text) {
11    component->print(text);
12}

步骤2：实现具体组件类

c

深色版本

1// 具体组件类
2typedef struct PlainText {
3    void (*print)(const char *text);
4} PlainText;
5
6void plainTextPrint(const char *text) {
7    printf("%s\n", text);
8}
9
10PlainText* createPlainText() {
11    PlainText *plainText = (PlainText *)malloc(sizeof(PlainText));
12    plainText->print = plainTextPrint;
13    return plainText;
14}

步骤3：实现装饰器类

c

深色版本

1// 装饰器类
2typedef struct Decorator {
3    Component *component;
4    void (*print)(const char *text);
5} Decorator;
6
7Decorator* createDecorator(Component *component) {
8    Decorator *decorator = (Decorator *)malloc(sizeof(Decorator));
9    decorator->component = component;
10    decorator->print = decoratorPrint;
11    return decorator;
12}
13
14void decoratorPrint(const char *text) {
15    if (decorator->component) {
16        decorator->component->print(text);
17    }
18}
19
20void destroyDecorator(Decorator *decorator) {
21    free(decorator);
22}

步骤4：实现具体装饰器类

c

深色版本

1// 具体装饰器类：加粗文本
2typedef struct BoldText {
3    Decorator decorator;
4} BoldText;
5
6void boldTextPrint(const char *text) {
7    printf("<b>%s</b>\n", text);
8}
9
10BoldText* createBoldText(Component *component) {
11    BoldText *boldText = (BoldText *)malloc(sizeof(BoldText));
12    boldText->decorator.component = component;
13    boldText->decorator.print = boldTextPrint;
14    return boldText;
15}
16
17void destroyBoldText(BoldText *boldText) {
18    destroyDecorator(&(boldText->decorator));
19    free(boldText);
20}
21
22// 具体装饰器类：斜体文本
23typedef struct ItalicText {
24    Decorator decorator;
25} ItalicText;
26
27void italicTextPrint(const char *text) {
28    printf("<i>%s</i>\n", text);
29}
30
31ItalicText* createItalicText(Component *component) {
32    ItalicText *italicText = (ItalicText *)malloc(sizeof(ItalicText));
33    italicText->decorator.component = component;
34    italicText->decorator.print = italicTextPrint;
35    return italicText;
36}
37
38void destroyItalicText(ItalicText *italicText) {
39    destroyDecorator(&(italicText->decorator));
40    free(italicText);
41}

步骤5：客户端代码

c

深色版本

1int main() {
2    PlainText *plainText = createPlainText();
3    Decorator *decorator = createDecorator((Component *)plainText);
4    BoldText *boldText = createBoldText((Component *)decorator);
5    ItalicText *italicText = createItalicText((Component *)decorator);
6
7    printText((Component *)plainText, "This is plain text.");
8    printText((Component *)boldText, "This is bold text.");
9    printText((Component *)italicText, "This is italic text.");
10
11    destroyItalicText(italicText);
12    destroyBoldText(boldText);
13    destroyDecorator(decorator);
14    destroyPlainText(plainText);
15
16    return 0;
17}

运行结果

当你运行上述 main 函数时，你会看到以下输出：

深色版本

1This is plain text.
2<b>This is bold text.</b>
3<i>This is italic text.</i>

解释

在这个例子中，PlainText 是基本的文本组件，它可以打印普通文本。通过 Decorator，我们可以为 PlainText 添加新的装饰，例如 BoldText 和 ItalicText。装饰器类 Decorator 包含了一个指向具体组件的指针，这样就可以在装饰器中调用具体组件的方法。通过这种方式，我们可以在运行时动态地为文本添加不同的格式。

装饰模式的优点

1. 灵活性：可以在运行时动态地添加职责。
2. 透明性：对于客户端来说，装饰模式和具体组件类看起来是一样的。
3. 可扩展性：可以通过组合多个装饰器来扩展功能。

装饰模式的缺点

1. 复杂度：使用多个装饰器可能会导致层次结构变得复杂。
2. 性能开销：在某些情况下，可能会有一些性能上的开销，尤其是在装饰器层次较深时。

总结

装饰模式通过动态地给对象添加职责，允许在不修改现有类的基础上扩展功能。这种模式特别适合需要在运行时动态添加功能的情况，同时也使得代码更加灵活和易于扩展。在设计系统时，可以根据需要选择是否使用装饰模式来增强系统的灵活性和可扩展性。