🎨 装饰模式详解

字数统计: 444字   |   阅读时长≈ 1分

🎯 导读：装饰模式是面向对象设计中极其精妙的结构型模式。如果说”策略模式”教你切换核心算法，那么”装饰模式”教你在不改变原有代码、也不使用无脑继承的情况下，动态地给对象叠加新功能。本文配有 📊 UML类图 和 💻 完整代码案例，带你彻底掌握这个”套娃”技巧！

🎭 1. 生动的比喻：楼下的煎饼果子摊

理解装饰模式最经典的现实场景，就是买煎饼果子（或者买奶茶）。

❌ 没有装饰模式（滥用继承的噩梦）

假设煎饼摊的老板是个没经验的程序员。他卖基础的”原味煎饼”。

顾客需求 老板的类设计
加个蛋 class 鸡蛋煎饼 : public 原味煎饼
加根火腿 class 火腿煎饼 : public 原味煎饼
加蛋加火腿 class 鸡蛋火腿煎饼 : public 原味煎饼
再加生菜、辣条、薄脆… 🤯 类爆炸💥！几十上百个子类！

🔥 问题：这就是典型的**”类爆炸”**，维护成本极高！

✅ 使用装饰模式（动态套娃）

聪明的摊主（架构师）转变了思路：

1
2
3
4
5
6
7
8
9
🥞 原味煎饼 (核心)
    ↓ 套上
🥚 鸡蛋装饰器
    ↓ 再套上
🥚 鸡蛋装饰器 (双蛋！)
    ↓ 最后套上
🌭 火腿装饰器
    ↓
🎉 双蛋火腿煎饼完成！

✅ 优势：

  • 🧩 只提供一个基础的 原味煎饼 对象
  • 🎁 所有配料都是装饰器
  • 🔄 运行时动态组合，没有任何多余的子类！

📊 2. UML 类图与核心角色

装饰模式的魔法在于：装饰器不仅”拥有”组件（组合关系），它本身也”是”一个组件（泛化关系）。

classDiagram
    class IPancake {
        + getDescription()
        + cost()
    }
    
    class BasePancake {
        + getDescription()
        + cost()
    }
    
    class CondimentDecorator {
        # wrappedPancake
        + getDescription()
        + cost()
    }
    
    class EggDecorator {
        + getDescription()
        + cost()
    }
    
    class SausageDecorator {
        + getDescription()
        + cost()
    }
    
    IPancake <|.. BasePancake : 实现
    IPancake <|.. CondimentDecorator : 实现
    CondimentDecorator <|-- EggDecorator : 继承
    CondimentDecorator <|-- SausageDecorator : 继承
    CondimentDecorator o-- IPancake : 组合

🔑 四大核心角色

角色 类名 职责 比喻
🎯 抽象构件 IPancake 定义基础契约（cost(), desc()） 煎饼的标准规格
🥞 具体构件 BasePancake 核心基础对象 原味煎饼
🎁 抽象装饰类 CondimentDecorator 魔法所在！ 继承+组合双重身份 配料包装盒
🥚🌭 具体装饰类 EggDecorator, SausageDecorator 具体配料，附加功能 鸡蛋、火腿

💡 魔法解析：CondimentDecorator 既继承了 IPancake（是一个煎饼），又组合了 IPancake（内部包着一个煎饼）。这使得它可以把自己伪装成普通组件，去替换被它包装的组件！

💻 3. C++ 现代代码生动演绎

🎯 智能指针版（推荐）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#include <iostream>
#include <string>
#include <memory>

// ==========================================
// 1. 抽象构件：煎饼的统一接口
// ==========================================
class IPancake {
public:
    virtual ~IPancake() = default;
    virtual std::string getDescription() const = 0;
    virtual double cost() const = 0;
};

// ==========================================
// 2. 具体构件：原味基础煎饼 (被包装的核心)
// ==========================================
class BasePancake : public IPancake {
public:
    std::string getDescription() const override {
        return "原味煎饼";
    }
    double cost() const override {
        return 5.0; // 基础价 5 元
    }
};

// ==========================================
// 3. 抽象装饰类：配料包装盒 (魔法核心)
// ==========================================
// 注意：它既继承了 IPancake (是一个煎饼)，又组合了 IPancake (内部包着一个煎饼)
class CondimentDecorator : public IPancake {
protected:
    // 使用独占智能指针，代表这个包装盒严丝合缝地包裹住了内部的煎饼
    std::unique_ptr<IPancake> wrappedPancake;

public:
    // 构造时，把里面的煎饼塞进包装盒
    CondimentDecorator(std::unique_ptr<IPancake> pancake) 
        : wrappedPancake(std::move(pancake)) {}

    // 默认行为：直接把任务委托给内部的煎饼去执行
    std::string getDescription() const override {
        return wrappedPancake->getDescription();
    }
    double cost() const override {
        return wrappedPancake->cost();
    }
};

// ==========================================
// 4. 具体装饰类：加鸡蛋
// ==========================================
class EggDecorator : public CondimentDecorator {
public:
    // 继承父类的构造
    EggDecorator(std::unique_ptr<IPancake> pancake) : CondimentDecorator(std::move(pancake)) {}

    std::string getDescription() const override {
        // 先调用内部煎饼的描述，然后加上自己的特色
        return wrappedPancake->getDescription() + " + 鸡蛋";
    }
    double cost() const override {
        // 先获取内部煎饼的价格，然后加上自己的价格
        return wrappedPancake->cost() + 1.5; // 加个蛋 1.5 元
    }
};

// ==========================================
// 4. 具体装饰类：加火腿
// ==========================================
class SausageDecorator : public CondimentDecorator {
public:
    SausageDecorator(std::unique_ptr<IPancake> pancake) : CondimentDecorator(std::move(pancake)) {}

    std::string getDescription() const override {
        return wrappedPancake->getDescription() + " + 火腿肠";
    }
    double cost() const override {
        return wrappedPancake->cost() + 2.0; // 加根火腿 2 元
    }
};

// ==========================================
// 业务调用端：老板，来个豪华煎饼！
// ==========================================
int main() {
    std::cout << "=== 顾客 A：老板，来个原味煎饼。 ===" << std::endl;
    std::unique_ptr<IPancake> myBreakfast = std::make_unique<BasePancake>();
    std::cout << "描述: " << myBreakfast->getDescription() << std::endl;
    std::cout << "价格: " << myBreakfast->cost() << " 元\n" << std::endl;

    std::cout << "=== 顾客 B：老板，来个双蛋一肠豪华版！ ===" << std::endl;
    // 1. 先摊个基础煎饼
    std::unique_ptr<IPancake> luxuryBreakfast = std::make_unique<BasePancake>();
    // 2. 动态套上一层鸡蛋外衣
    luxuryBreakfast = std::make_unique<EggDecorator>(std::move(luxuryBreakfast));
    // 3. 再动态套上一层鸡蛋外衣 (双蛋)
    luxuryBreakfast = std::make_unique<EggDecorator>(std::move(luxuryBreakfast));
    // 4. 最后套上一层火腿外衣
    luxuryBreakfast = std::make_unique<SausageDecorator>(std::move(luxuryBreakfast));

    // 此时调用，它会像剥洋葱一样，一层一层往里传导，再一层一层计算出来！
    std::cout << "描述: " << luxuryBreakfast->getDescription() << std::endl;
    std::cout << "价格: " << luxuryBreakfast->cost() << " 元" << std::endl;

    return 0;
}

📤 输出结果

1
2
3
4
5
6
7
=== 顾客 A：老板，来个原味煎饼。 ===
描述: 原味煎饼
价格: 5 元

=== 顾客 B：老板，来个双蛋一肠豪华版！ ===
描述: 原味煎饼 + 鸡蛋 + 鸡蛋 + 火腿肠
价格: 10 元

🔧 普通指针版（兼容旧代码）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include <iostream>
#include <string>

// ==========================================
// 1. 抽象构件：煎饼的统一接口
// ==========================================
class IPancake {
public:
    virtual ~IPancake() = default; // 虚析构函数依然是必须的
    virtual std::string getDescription() const = 0;
    virtual double cost() const = 0;
};

// ==========================================
// 2. 具体构件：原味基础煎饼
// ==========================================
class BasePancake : public IPancake {
public:
    std::string getDescription() const override {
        return "原味煎饼";
    }
    double cost() const override {
        return 5.0;
    }
};

// ==========================================
// 3. 抽象装饰类：配料包装盒 (使用裸指针)
// ==========================================
class CondimentDecorator : public IPancake {
protected:
    // 【修改 1】：退化为传统的裸指针
    IPancake* wrappedPancake;

public:
    // 构造时传入裸指针
    CondimentDecorator(IPancake* pancake) : wrappedPancake(pancake) {}

    // 【修改 2（极其重要）】：必须手动提供析构函数来释放内部包裹的对象！
    // 否则，当你 delete 最外层的煎饼时，里面的煎饼全都会变成内存泄漏。
    ~CondimentDecorator() override {
        if (wrappedPancake != nullptr) {
            delete wrappedPancake;
            wrappedPancake = nullptr;
        }
    }

    std::string getDescription() const override {
        return wrappedPancake->getDescription();
    }
    double cost() const override {
        return wrappedPancake->cost();
    }
};

// ==========================================
// 4. 具体装饰类：加鸡蛋
// ==========================================
class EggDecorator : public CondimentDecorator {
public:
    EggDecorator(IPancake* pancake) : CondimentDecorator(pancake) {}

    std::string getDescription() const override {
        return wrappedPancake->getDescription() + " + 鸡蛋";
    }
    double cost() const override {
        return wrappedPancake->cost() + 1.5;
    }
};

// ==========================================
// 4. 具体装饰类：加火腿
// ==========================================
class SausageDecorator : public CondimentDecorator {
public:
    SausageDecorator(IPancake* pancake) : CondimentDecorator(pancake) {}

    std::string getDescription() const override {
        return wrappedPancake->getDescription() + " + 火腿肠";
    }
    double cost() const override {
        return wrappedPancake->cost() + 2.0;
    }
};

// ==========================================
// 业务调用端
// ==========================================
int main() {
    std::cout << "=== 顾客 A：老板，来个原味煎饼。 ===" << std::endl;
    // 使用 new 创建裸指针对象
    IPancake* myBreakfast = new BasePancake();
    std::cout << "描述: " << myBreakfast->getDescription() << std::endl;
    std::cout << "价格: " << myBreakfast->cost() << " 元\n" << std::endl;
    
    // 【修改 3】：用完必须手动释放！
    delete myBreakfast;


    std::cout << "=== 顾客 B：老板，来个双蛋一肠豪华版！ ===" << std::endl;
    // 1. 先摊个基础煎饼
    IPancake* luxuryBreakfast = new BasePancake();
    
    // 2. 动态套上一层层外衣 (直接把指针传进去，并覆盖原来的指针变量)
    luxuryBreakfast = new EggDecorator(luxuryBreakfast);
    luxuryBreakfast = new EggDecorator(luxuryBreakfast);
    luxuryBreakfast = new SausageDecorator(luxuryBreakfast);

    std::cout << "描述: " << luxuryBreakfast->getDescription() << std::endl;
    std::cout << "价格: " << luxuryBreakfast->cost() << " 元\n" << std::endl;

    // 【修改 4】：释放内存的链式反应
    // 这里只需要 delete 最外层的指针。
    // 因为我们在 CondimentDecorator 中写了析构函数，它会像剥洋葱一样，
    // 自动一层一层往内部调用 delete，彻底释放所有内存。
    delete luxuryBreakfast;

    return 0;
}

🔍 深入理解：指针传递与内存释放全过程

别担心，装饰模式的指针传递和内存释放过程，确实是很多初学者最容易绕晕的地方。把它想象成 俄罗斯套娃 或者 包快递 的过程，就会非常清晰了。我们一行一行来拆解，看看在计算机内存里到底发生了什么。

第一阶段：构造过程（从内向外包）

在代码中，我们是这样写的：

1
2
3
4
5
6
// 第 1 步
IPancake* luxuryBreakfast = new BasePancake();
// 第 2 步
luxuryBreakfast = new EggDecorator(luxuryBreakfast);
// 第 3 步
luxuryBreakfast = new SausageDecorator(luxuryBreakfast);

我们来看看内存里是怎么变化的：

第 1 步：摊基础煎饼

  • 内存中生成了一个 BasePancake 对象（我们叫它 对象A）。
  • 指针 luxuryBreakfast 目前指向 对象A。
1
2
3
4
5
6
7
内存状态：
┌─────────────────────┐
│   BasePancake (A)   │
│   - 价格: 5元       │
└─────────────────────┘
         ↑
    luxuryBreakfast

第 2 步：加鸡蛋

  • new EggDecorator(...) 在内存中生成了一个鸡蛋包装盒（对象B）。
  • 构造时，我们把当前的 luxuryBreakfast（也就是 对象A 的地址）传给了它。所以，对象B 的肚子里（wrappedPancake 指针）装进了 对象A。
  • 然后，代码最前面的 = 号，让 luxuryBreakfast 指针改变了指向，它现在指向了最外层的 对象B。
1
2
3
4
5
6
7
8
9
10
11
内存状态：
┌─────────────────────────────┐
│   EggDecorator (B)          │
│   - wrappedPancake ───────┐ │
└───────────────────────────┼─┘
                            ↓
                    ┌─────────────────────┐
                    │   BasePancake (A)   │
                    └─────────────────────┘
                            ↑
                       luxuryBreakfast

第 3 步：加火腿

  • new SausageDecorator(...) 在内存中生成了一个火腿包装盒（对象C）。
  • 构造时，我们把当前的 luxuryBreakfast（此时是 对象B 的地址）传给了它。所以，对象C 的肚子里装进了 对象B。
  • 指针 luxuryBreakfast 再次改变指向，最终指向了最外层的 对象C。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
内存状态：
┌─────────────────────────────┐
│   SausageDecorator (C)      │
│   - wrappedPancake ───────┐ │
└───────────────────────────┼─┘
                            ↓
                    ┌─────────────────────────────┐
                    │   EggDecorator (B)          │
                    │   - wrappedPancake ───────┐ │
                    └───────────────────────────┼─┘
                                                ↓
                                        ┌─────────────────────┐
                                        │   BasePancake (A)   │
                                        └─────────────────────┘
                                                ↑
                                           luxuryBreakfast

📝 构造总结：顺序是 从内向外（先有原味煎饼，再套鸡蛋，最后套火腿）。最终你手里拿到的指针，永远是最外层那个包装盒的指针。

第二阶段：调用方法的过程（从外向内，再向外返回）

当我们调用 luxuryBreakfast->cost() 时：

  1. **进入火腿层 (对象C)**：火腿类的 cost() 方法被触发。它的代码是 wrappedPancake->cost() + 2.0;。它不知道总价，必须先问它肚子里的兄弟。

  2. **进入鸡蛋层 (对象B)**：鸡蛋类的 cost() 方法被触发。它的代码是 wrappedPancake->cost() + 1.5;。它也不知道总价，继续向里问。

  3. **进入核心层 (对象A)**：基础煎饼的 cost() 被触发。它直接返回了 5.0。

  4. 层层返回：

    • 基础煎饼把 5.0 传给鸡蛋层。
    • 鸡蛋层拿到 5.0，加上自己的 1.5，把 6.5 传给火腿层。
    • 火腿层拿到 6.5，加上自己的 2.0，最终返回 8.5 给调用者。
1
2
3
4
5
6
7
8
调用流程（像剥洋葱）：
SausageDecorator.cost() 
  → EggDecorator.cost()
    → EggDecorator.cost()
      → BasePancake.cost() 返回 5
    → 5 + 1.5 = 6.5
  → 6.5 + 1.5 = 8.0
→ 8.0 + 2.0 = 10.0 ✨

第三阶段：析构（释放内存）的过程（链式反应）

这是最关键、也是最容易发生内存泄漏的地方。当我们吃完煎饼，执行 delete luxuryBreakfast; 时，发生了什么？

记住，luxuryBreakfast 现在指向的是最外层的 对象C（火腿包装盒）。

销毁火腿层 (对象C)

  • 程序首先调用 对象C 的析构函数 ~CondimentDecorator()。
  • 这个析构函数里写了极其致命的一句代码：delete wrappedPancake;。
  • 对对象C来说，它肚子里的 wrappedPancake 是 对象B（鸡蛋层） 的指针。
  • 于是，这就触发了对 对象B 的 delete 操作。

销毁鸡蛋层 (对象B)

  • 程序进入 对象B 的析构函数 ~CondimentDecorator()。
  • 同样，它执行了 delete wrappedPancake;。
  • 对对象B来说，它肚子里的指针是 对象A（基础煎饼）。
  • 于是，触发了对 对象A 的 delete 操作。

销毁核心层 (对象A)

  • 程序进入 对象A 的析构函数 ~BasePancake()。
  • 对象A是最里面的核心，肚子里没有别人了。它安详地释放了属于自己的那块内存。

内存彻底清空

  • 对象A 释放完毕。
  • 对象B 随即释放完毕。
  • 对象C 最终释放完毕。
1
2
3
4
5
6
7
8
析构流程（链式反应）：
delete luxuryBreakfast (指向对象C)
  → ~SausageDecorator() 执行 delete wrappedPancake (对象B)
    → ~EggDecorator() 执行 delete wrappedPancake (对象A)
      → ~BasePancake() 释放核心对象
    → 对象B 释放完毕
  → 对象C 释放完毕
✨ 内存干干净净，无泄漏！

📝 析构总结：顺序是 从外向内下达指令，从内向外依次销毁。这就像引爆了一根导火索，只要最外层的盒子被 delete，它就会自动去 delete 里面的盒子，里面的盒子再去 delete 更里面的盒子，直到最核心的对象被销毁，干干净净，没有任何内存泄漏。

🎨 4. 对象结构图解

让我们看看运行时对象是如何”套娃”的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
顾客 B 的豪华煎饼对象结构：

┌─────────────────────────────────────────┐
│     SausageDecorator (火腿肠装饰器)      │
│  ┌───────────────────────────────────┐  │
│  │      EggDecorator (鸡蛋装饰器)     │  │
│  │  ┌─────────────────────────────┐  │  │
│  │  │    EggDecorator (鸡蛋装饰器) │  │  │
│  │  │  ┌───────────────────────┐  │  │  │
│  │  │  │   BasePancake (原味)   │  │  │  │
│  │  │  │  - 描述: "原味煎饼"     │  │  │  │
│  │  │  │  - 价格: 5元            │  │  │  │
│  │  │  └───────────────────────┘  │  │  │
│  │  │  + 鸡蛋: +1.5元              │  │  │
│  │  └─────────────────────────────┘  │  │
│  │  + 鸡蛋: +1.5元                    │  │
│  └───────────────────────────────────┘  │
│  + 火腿肠: +2.0元                        │
└─────────────────────────────────────────┘

调用 cost() 时的执行流程（像剥洋葱）：
SausageDecorator.cost() 
  → EggDecorator.cost()
    → EggDecorator.cost()
      → BasePancake.cost() 返回 5
    → 5 + 1.5 = 6.5
  → 6.5 + 1.5 = 8.0
→ 8.0 + 2.0 = 10.0 ✨

📋 5. 优缺点与真实工业场景

✅ 优点

优点 说明
🧩 极度灵活，拒绝类爆炸 遵守合成复用原则（多用组合，少用继承）和开闭原则。加新配料只需写新装饰类，不影响老代码
🔄 动态可插拔 继承是编译时写死的，装饰模式是运行时像拼乐高一样随意组合
🎯 单一职责 每个装饰类只负责一个功能，代码清晰易维护

❌ 缺点

缺点 说明
📦 产生大量小对象 代码里多出一堆细碎的小包装类（鸡蛋类、火腿类）
🐛 排错较困难 由于层层嵌套像洋葱，Debug 时可能要剥好几层才能找到核心对象

🏭 真实工业场景

在底层框架或流处理模块中，装饰模式用得极其频繁：

C++ I/O 流系统

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 核心基础类
FileStream file("data.bin");

// 套一层缓冲，提高效率
BufferedOutputStream buffered(&file);

// 再套一层加密，防止泄密
CryptoOutputStream encrypted(&buffered);

// 再套一层压缩
ZipOutputStream compressed(&encrypted);

// 最终代码优雅到极致：
auto out = new ZipOutputStream(
    new CryptoOutputStream(
        new BufferedOutputStream(
            new FileStream("data.bin")
        )
    )
);

网络数据发送

层级 装饰器 功能
核心 SocketStream 基础网络流
+1层 BufferedStream 缓冲优化
+2层 SSLStream 加密传输
+3层 GzipStream 压缩数据

🎯 6. 装饰模式 vs 继承

继承方式（类爆炸）

classDiagram
    class Pancake {
        + cost()
    }
    
    class EggPancake {
        + cost()
    }
    
    class SausagePancake {
        + cost()
    }
    
    class EggSausagePancake {
        + cost()
    }
    
    class DoubleEggPancake {
        + cost()
    }
    
    Pancake <|-- EggPancake : 继承
    Pancake <|-- SausagePancake : 继承
    Pancake <|-- EggSausagePancake : 继承
    Pancake <|-- DoubleEggPancake : 继承

装饰模式方式（灵活组合）

classDiagram
    class IPancake {
        + cost()
    }
    
    class BasePancake {
        + cost()
    }
    
    class CondimentDecorator {
        + cost()
    }
    
    class EggDecorator {
        + cost()
    }
    
    class SausageDecorator {
        + cost()
    }
    
    IPancake <|.. BasePancake : 实现
    IPancake <|.. CondimentDecorator : 实现
    CondimentDecorator <|-- EggDecorator : 继承
    CondimentDecorator <|-- SausageDecorator : 继承
    CondimentDecorator o-- IPancake : 组合
对比项 继承 装饰模式
类数量 指数增长 📈 线性增长 📊
灵活性 编译时固定 🔒 运行时动态 🔄
开闭原则 违反 ❌ 遵守 ✅
代码复用 通过继承 通过组合

🎓 总结

装饰模式是结构型模式中的经典之作，它完美诠释了：

🎯 “多用组合，少用继承” 的设计哲学

通过继承+组合的双重身份，装饰器既能伪装成被装饰对象，又能层层包装添加功能，实现了功能的动态叠加而不产生类爆炸。

📝 记忆口诀

“套娃装饰，层层叠加；组合继承，灵活优雅” 🎁

📝 本文通过 🎭 生活比喻、📊 UML类图、💻 完整代码案例，帮助你深入理解装饰模式。希望对你有所帮助！

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

僕は新世界の神となる!