06.C++设计模式-装饰模式

1. 模式定义

装饰模式（Decorator Pattern）是一种结构型设计模式，允许动态地向一个现有对象添加新的功能，同时不改变其结构。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供额外的功能。

2. 核心特点

• 替代继承：提供比继承更灵活的扩展方式
• 透明性：装饰类与被装饰类具有相同的接口
• 动态性：运行时动态添加/撤销功能
• 开闭原则：对扩展开放，对修改关闭

3. 模式结构

4. 应用场景

典型场景：

1. IO流处理（Java/C++流库）
2. GUI组件（添加滚动条、边框等）
3. 咖啡/披萨订单系统（添加配料）
4. 权限系统（动态添加角色权限）
5. 日志系统（不同格式/输出方式）
6. 数据压缩/加密（透明附加功能）

实战案例：

• 游戏装备系统（武器附魔）
• 文本编辑器（字体、颜色、下划线等格式）
• 图片处理（滤镜、水印、边框）

5. C++代码示例

基础示例：咖啡订单系统

1. #include <iostream>
2. #include <memory>
3. #include <string>
5. // 抽象组件：饮料
6. class Beverage {
7. public:
8. virtual ~Beverage() = default;
9. virtual std::string getDescription() const = 0;
10. virtual double cost() const = 0;
11. };
13. // 具体组件：浓缩咖啡
14. class Espresso : public Beverage {
15. public:
16. std::string getDescription() const override {
17. return "浓缩咖啡";
18. }
20. double cost() const override {
21. return 25.0;
22. }
23. };
25. // 具体组件：混合咖啡
26. class HouseBlend : public Beverage {
27. public:
28. std::string getDescription() const override {
29. return "混合咖啡";
30. }
32. double cost() const override {
33. return 20.0;
34. }
35. };
37. // 抽象装饰类
38. class CondimentDecorator : public Beverage {
39. protected:
40. std::unique_ptr<Beverage> beverage;
42. public:
43. CondimentDecorator(std::unique_ptr<Beverage> bev)
44. : beverage(std::move(bev)) {}
46. virtual ~CondimentDecorator() = default;
48. std::string getDescription() const override {
49. return beverage->getDescription();
50. }
52. double cost() const override {
53. return beverage->cost();
54. }
55. };
57. // 具体装饰：牛奶
58. class Milk : public CondimentDecorator {
59. public:
60. Milk(std::unique_ptr<Beverage> bev)
61. : CondimentDecorator(std::move(bev)) {}
63. std::string getDescription() const override {
64. return beverage->getDescription() + " + 牛奶";
65. }
67. double cost() const override {
68. return beverage->cost() + 5.0;
69. }
70. };
72. // 具体装饰：摩卡
73. class Mocha : public CondimentDecorator {
74. public:
75. Mocha(std::unique_ptr<Beverage> bev)
76. : CondimentDecorator(std::move(bev)) {}
78. std::string getDescription() const override {
79. return beverage->getDescription() + " + 摩卡";
80. }
82. double cost() const override {
83. return beverage->cost() + 8.0;
84. }
85. };
87. // 具体装饰：奶泡
88. class Whip : public CondimentDecorator {
89. public:
90. Whip(std::unique_ptr<Beverage> bev)
91. : CondimentDecorator(std::move(bev)) {}
93. std::string getDescription() const override {
94. return beverage->getDescription() + " + 奶泡";
95. }
97. double cost() const override {
98. return beverage->cost() + 4.0;
99. }
100. };
102. // 客户端使用
103. int main() {
104. // 一杯浓缩咖啡 + 双份牛奶
105. auto beverage1 = std::make_unique<Espresso>();
106. beverage1 = std::make_unique<Milk>(std::move(beverage1));
107. beverage1 = std::make_unique<Milk>(std::move(beverage1));
109. std::cout << "订单1: " << beverage1->getDescription()
110. << " | 价格: ¥" << beverage1->cost() << std::endl;
112. // 混合咖啡 + 摩卡 + 奶泡
113. auto beverage2 = std::make_unique<HouseBlend>();
114. beverage2 = std::make_unique<Mocha>(std::move(beverage2));
115. beverage2 = std::make_unique<Whip>(std::move(beverage2));
117. std::cout << "订单2: " << beverage2->getDescription()
118. << " | 价格: ¥" << beverage2->cost() << std::endl;
120. return 0;
121. }

复制代码

高级示例：数据流处理

1. #include <iostream>
2. #include <string>
3. #include <algorithm>
5. // 抽象数据流
6. class DataStream {
7. public:
8. virtual ~DataStream() = default;
9. virtual std::string read() = 0;
10. virtual void write(const std::string& data) = 0;
11. };
13. // 具体组件：文件流
14. class FileStream : public DataStream {
15. public:
16. std::string read() override {
17. return "原始文件数据";
18. }
20. void write(const std::string& data) override {
21. std::cout << "写入文件: " << data << std::endl;
22. }
23. };
25. // 抽象装饰器
26. class StreamDecorator : public DataStream {
27. protected:
28. DataStream* stream;
30. public:
31. StreamDecorator(DataStream* s) : stream(s) {}
32. virtual ~StreamDecorator() { delete stream; }
34. std::string read() override {
35. return stream->read();
36. }
38. void write(const std::string& data) override {
39. stream->write(data);
40. }
41. };
43. // 加密装饰器
44. class EncryptionDecorator : public StreamDecorator {
45. private:
46. std::string encrypt(const std::string& data) {
47. std::string encrypted = data;
48. for (char& c : encrypted) {
49. c = c ^ 0xFF; // 简单的异或加密
50. }
51. return encrypted;
52. }
54. std::string decrypt(const std::string& data) {
55. return encrypt(data); // 异或两次恢复原值
56. }
58. public:
59. EncryptionDecorator(DataStream* s) : StreamDecorator(s) {}
61. std::string read() override {
62. std::string data = StreamDecorator::read();
63. return decrypt(data);
64. }
66. void write(const std::string& data) override {
67. std::string encrypted = encrypt(data);
68. StreamDecorator::write(encrypted);
69. }
70. };
72. // 压缩装饰器
73. class CompressionDecorator : public StreamDecorator {
74. private:
75. std::string compress(const std::string& data) {
76. // 模拟压缩：重复字符计数
77. std::string compressed;
78. for (size_t i = 0; i < data.length(); ++i) {
79. if (i == 0 || data[i] != data[i-1]) {
80. compressed += data[i];
81. }
82. }
83. return compressed;
84. }
86. std::string decompress(const std::string& data) {
87. // 模拟解压（简单场景）
88. return data;
89. }
91. public:
92. CompressionDecorator(DataStream* s) : StreamDecorator(s) {}
94. std::string read() override {
95. std::string data = StreamDecorator::read();
96. return decompress(data);
97. }
99. void write(const std::string& data) override {
100. std::string compressed = compress(data);
101. StreamDecorator::write(compressed);
102. }
103. };
105. // 使用示例
106. int main() {
107. // 基础文件流
108. DataStream* file = new FileStream();
109. file->write("Hello World");
111. // 添加加密功能
112. DataStream* encrypted = new EncryptionDecorator(file);
113. encrypted->write("Sensitive Data");
115. // 添加压缩+加密功能
116. DataStream* compressed = new CompressionDecorator(
117. new EncryptionDecorator(new FileStream())
118. );
119. compressed->write("Important Content");
121. delete compressed;
122. delete encrypted;
124. return 0;
125. }

复制代码

6. 装饰模式 vs 继承

7. 优点与缺点

优点 ✅

• 灵活性：运行时动态添加/删除功能
• 避免类爆炸：无需为每个组合创建子类
• 单一职责：每个装饰类只负责一个功能
• 组合优于继承：更符合设计原则

缺点 ❌

• 增加复杂度：产生大量小类
• 调试困难：层层包装，追踪较难
• 类型识别问题：装饰后的对象类型发生变化

8. 最佳实践

1. 保持接口一致：装饰类必须实现被装饰类的接口
2. 避免过度装饰：装饰链不要超过3-4层
3. 考虑使用工厂模式：创建复杂的装饰组合
4. 注意性能影响：每层装饰都有额外开销

9.装饰模式与工厂模式的结合

装饰模式和工厂模式的结合是一种常见的设计模式组合，可以有效解决装饰对象的创建和管理问题。

9.1 为什么要结合？

9.2 结合方式

方式一：简单工厂 + 装饰模式

1. #include <iostream>
2. #include <memory>
3. #include <string>
4. #include <map>
6. // 饮料基类
7. class Beverage {
8. public:
9. virtual ~Beverage() = default;
10. virtual std::string getDescription() const = 0;
11. virtual double cost() const = 0;
12. };
14. // 具体饮料类
15. class Espresso : public Beverage {
16. public:
17. std::string getDescription() const override { return "浓缩咖啡"; }
18. double cost() const override { return 25.0; }
19. };
21. class Latte : public Beverage {
22. public:
23. std::string getDescription() const override { return "拿铁咖啡"; }
24. double cost() const override { return 30.0; }
25. };
27. // 装饰器基类
28. class CondimentDecorator : public Beverage {
29. protected:
30. std::unique_ptr<Beverage> beverage;
31. public:
32. CondimentDecorator(std::unique_ptr<Beverage> bev)
33. : beverage(std::move(bev)) {}
34. };
36. // 具体装饰器
37. class Milk : public CondimentDecorator {
38. public:
39. Milk(std::unique_ptr<Beverage> bev) : CondimentDecorator(std::move(bev)) {}
40. std::string getDescription() const override {
41. return beverage->getDescription() + " + 牛奶";
42. }
43. double cost() const override { return beverage->cost() + 5.0; }
44. };
46. class Mocha : public CondimentDecorator {
47. public:
48. Mocha(std::unique_ptr<Beverage> bev) : CondimentDecorator(std::move(bev)) {}
49. std::string getDescription() const override {
50. return beverage->getDescription() + " + 摩卡";
51. }
52. double cost() const override { return beverage->cost() + 8.0; }
53. };
55. // ========== 简单工厂 ==========
56. class CoffeeFactory {
57. public:
58. enum CoffeeType { ESPRESSO, LATTE };
60. static std::unique_ptr<Beverage> createCoffee(CoffeeType type) {
61. switch (type) {
62. case ESPRESSO: return std::make_unique<Espresso>();
63. case LATTE: return std::make_unique<Latte>();
64. default: return nullptr;
65. }
66. }
68. // 预定义的组合
69. static std::unique_ptr<Beverage> createSignatureLatte() {
70. auto coffee = std::make_unique<Latte>();
71. coffee = std::make_unique<Milk>(std::move(coffee));
72. coffee = std::make_unique<Mocha>(std::move(coffee));
73. return coffee;
74. }
75. };
77. // 使用示例
78. int main() {
79. // 使用工厂创建基础咖啡
80. auto coffee1 = CoffeeFactory::createCoffee(CoffeeFactory::ESPRESSO);
81. coffee1 = std::make_unique<Milk>(std::move(coffee1));
82. std::cout << coffee1->getDescription() << ": ¥" << coffee1->cost() << std::endl;
84. // 使用工厂创建复杂组合
85. auto signature = CoffeeFactory::createSignatureLatte();
86. std::cout << signature->getDescription() << ": ¥" << signature->cost() << std::endl;
88. return 0;
89. }

复制代码

方式二：工厂方法 + 装饰模式

1. #include <iostream>
2. #include <memory>
3. #include <vector>
5. // 装饰器类型枚举
6. enum class Topping { MILK, MOCHA, WHIP, SOY };
8. // 抽象工厂
9. class BeverageFactory {
10. public:
11. virtual ~BeverageFactory() = default;
12. virtual std::unique_ptr<Beverage> createBeverage() = 0;
13. virtual std::unique_ptr<Beverage> createWithToppings(
14. const std::vector<Topping>& toppings) = 0;
15. };
17. // 具体工厂：浓缩咖啡工厂
18. class EspressoFactory : public BeverageFactory {
19. private:
20. std::unique_ptr<Beverage> applyToppings(
21. std::unique_ptr<Beverage> beverage,
22. const std::vector<Topping>& toppings) {
24. for (auto topping : toppings) {
25. switch (topping) {
26. case Topping::MILK:
27. beverage = std::make_unique<Milk>(std::move(beverage));
28. break;
29. case Topping::MOCHA:
30. beverage = std::make_unique<Mocha>(std::move(beverage));
31. break;
32. default:
33. break;
34. }
35. }
36. return beverage;
37. }
39. public:
40. std::unique_ptr<Beverage> createBeverage() override {
41. return std::make_unique<Espresso>();
42. }
44. std::unique_ptr<Beverage> createWithToppings(
45. const std::vector<Topping>& toppings) override {
46. auto beverage = createBeverage();
47. return applyToppings(std::move(beverage), toppings);
48. }
49. };
51. // 使用示例
52. int main() {
53. EspressoFactory factory;
55. // 创建纯浓缩咖啡
56. auto espresso = factory.createBeverage();
58. // 创建加牛奶和摩卡的浓缩咖啡
59. auto deluxe = factory.createWithToppings({Topping::MILK, Topping::MOCHA});
61. std::cout << deluxe->getDescription() << ": ¥" << deluxe->cost() << std::endl;
63. return 0;
64. }

复制代码

方式三：抽象工厂 + 装饰模式

1. #include <iostream>
2. #include <memory>
3. #include <map>
4. #include <functional>
6. // 装饰器创建函数类型
7. using DecoratorCreator = std::function<std::unique_ptr<Beverage>(std::unique_ptr<Beverage>)>;
9. // 装饰器注册表
10. class DecoratorRegistry {
11. private:
12. std::map<std::string, DecoratorCreator> creators;
14. public:
15. void registerDecorator(const std::string& name, DecoratorCreator creator) {
16. creators[name] = creator;
17. }
19. DecoratorCreator getCreator(const std::string& name) {
20. auto it = creators.find(name);
21. if (it != creators.end()) {
22. return it->second;
23. }
24. return nullptr;
25. }
26. };
28. // 全局注册表
29. DecoratorRegistry& getRegistry() {
30. static DecoratorRegistry registry;
31. return registry;
32. }
34. // 自动注册类
35. class AutoRegister {
36. public:
37. AutoRegister(const std::string& name, DecoratorCreator creator) {
38. getRegistry().registerDecorator(name, creator);
39. }
40. };
42. // 注册装饰器（使用静态初始化）
43. static AutoRegister registerMilk("milk", [](std::unique_ptr<Beverage> b) {
44. return std::make_unique<Milk>(std::move(b));
45. });
47. static AutoRegister registerMocha("mocha", [](std::unique_ptr<Beverage> b) {
48. return std::make_unique<Mocha>(std::move(b));
49. });
51. // 抽象工厂：支持配置驱动
52. class ConfigurableCoffeeFactory {
53. private:
54. std::string baseCoffee;
55. std::vector<std::string> toppings;
57. public:
58. ConfigurableCoffeeFactory(const std::string& coffee,
59. const std::vector<std::string>& toppings)
60. : baseCoffee(coffee), toppings(toppings) {}
62. std::unique_ptr<Beverage> create() {
63. std::unique_ptr<Beverage> beverage;
65. // 创建基础咖啡
66. if (baseCoffee == "espresso") {
67. beverage = std::make_unique<Espresso>();
68. } else if (baseCoffee == "latte") {
69. beverage = std::make_unique<Latte>();
70. } else {
71. return nullptr;
72. }
74. // 动态应用装饰器
75. for (const auto& topping : toppings) {
76. auto creator = getRegistry().getCreator(topping);
77. if (creator) {
78. beverage = creator(std::move(beverage));
79. }
80. }
82. return beverage;
83. }
84. };
86. // 使用示例：类似配置文件解析
87. int main() {
88. // 模拟从配置文件读取
89. std::map<std::string, std::vector<std::string>> orders = {
90. {"order1", {"espresso", "milk", "mocha"}},
91. {"order2", {"latte", "milk"}},
92. {"order3", {"espresso", "milk", "milk", "mocha"}} // 双份牛奶
93. };
95. for (const auto& [orderId, config] : orders) {
96. if (config.size() < 1) continue;
98. std::string coffeeType = config[0];
99. std::vector<std::string> toppings(config.begin() + 1, config.end());
101. ConfigurableCoffeeFactory factory(coffeeType, toppings);
102. auto beverage = factory.create();
104. if (beverage) {
105. std::cout << orderId << ": " << beverage->getDescription()
106. << " | ¥" << beverage->cost() << std::endl;
107. }
108. }
110. return 0;
111. }

复制代码

方式四：建造者模式结合

1. #include <iostream>
2. #include <memory>
3. #include <vector>
5. // 装饰器构建器
6. class CoffeeBuilder {
7. private:
8. std::unique_ptr<Beverage> beverage;
10. public:
11. CoffeeBuilder& setBase(std::unique_ptr<Beverage> base) {
12. beverage = std::move(base);
13. return *this;
14. }
16. CoffeeBuilder& addMilk() {
17. if (beverage) {
18. beverage = std::make_unique<Milk>(std::move(beverage));
19. }
20. return *this;
21. }
23. CoffeeBuilder& addMocha() {
24. if (beverage) {
25. beverage = std::make_unique<Mocha>(std::move(beverage));
26. }
27. return *this;
28. }
30. CoffeeBuilder& addWhip() {
31. if (beverage) {
32. beverage = std::make_unique<Whip>(std::move(beverage));
33. }
34. return *this;
35. }
37. std::unique_ptr<Beverage> build() {
38. return std::move(beverage);
39. }
40. };
42. // 工厂类使用建造者
43. class CoffeeShop {
44. public:
45. static std::unique_ptr<Beverage> createStandardLatte() {
46. return CoffeeBuilder()
47. .setBase(std::make_unique<Latte>())
48. .addMilk()
49. .build();
50. }
52. static std::unique_ptr<Beverage> createDeluxeMocha() {
53. return CoffeeBuilder()
54. .setBase(std::make_unique<Espresso>())
55. .addMilk()
56. .addMocha()
57. .addWhip()
58. .build();
59. }
61. // 支持自定义
62. static std::unique_ptr<Beverage> customOrder(
63. std::unique_ptr<Beverage> base,
64. bool hasMilk, bool hasMocha, bool hasWhip) {
66. CoffeeBuilder builder;
67. builder.setBase(std::move(base));
69. if (hasMilk) builder.addMilk();
70. if (hasMocha) builder.addMocha();
71. if (hasWhip) builder.addWhip();
73. return builder.build();
74. }
75. };
77. int main() {
78. auto latte = CoffeeShop::createStandardLatte();
79. std::cout << latte->getDescription() << ": ¥" << latte->cost() << std::endl;
81. auto mocha = CoffeeShop::createDeluxeMocha();
82. std::cout << mocha->getDescription() << ": ¥" << mocha->cost() << std::endl;
84. auto custom = CoffeeShop::customOrder(
85. std::make_unique<Latte>(),
86. true, true, false // 加牛奶和摩卡，不加奶泡
87. );
88. std::cout << custom->getDescription() << ": ¥" << custom->cost() << std::endl;
90. return 0;
91. }

复制代码

3. 结合的优势对比

4. 最佳实践建议

场景	推荐方式	原因
装饰器种类少（<5种）	简单工厂	实现简单，够用
装饰器有层次关系	工厂方法	支持继承扩展
需要灵活配置	抽象工厂+注册表	配置驱动，热插拔
复杂构建过程	建造者模式	链式调用，可读性强

5. 实际应用场景

1. // 实战：UI组件装饰工厂
2. class UIComponentFactory {
3. public:
4. static std::unique_ptr<Component> createStyledButton(
5. const std::string& text,
6. const std::vector<std::string>& styles) {
8. auto button = std::make_unique<Button>(text);
10. for (const auto& style : styles) {
11. if (style == "border") {
12. button = std::make_unique<BorderDecorator>(std::move(button));
13. } else if (style == "shadow") {
14. button = std::make_unique<ShadowDecorator>(std::move(button));
15. } else if (style == "rounded") {
16. button = std::make_unique<RoundedDecorator>(std::move(button));
17. }
18. }
20. return button;
21. }
22. };
24. // 使用
25. auto btn = UIComponentFactory::createStyledButton("Click Me",
26. {"border", "shadow", "rounded"});

复制代码

这种结合方式既保持了装饰模式的灵活性，又通过工厂模式解决了对象创建的复杂度问题，是实际项目中的常用组合。