装饰器模式的核心思路是通过组合替代继承，在不改变原有对象结构的基础上，将额外的功能附加到对象上，实现动态扩展对象行为的目的。这种模式非常适合需要灵活叠加多种功能的场景，比如给基础组件逐步添加日志、缓存、权限校验等能力。
装饰器模式的核心角色
在C++中实现装饰器模式，通常需要定义以下几个核心角色：
- 抽象组件（Component）：定义对象的通用接口，是被装饰对象和装饰器共同实现的基类，确保所有装饰器和原始对象拥有统一的调用方式。
- 具体组件（ConcreteComponent）：抽象组件的具体实现类，是需要被装饰的原始对象，包含基础的核心功能。
- 抽象装饰器（Decorator）：继承抽象组件，同时持有一个抽象组件的指针或引用，是所有具体装饰器的基类，负责转发请求到被装饰对象。
- 具体装饰器（ConcreteDecorator）：继承抽象装饰器，在实现接口时，先调用被装饰对象的方法，再添加自己的额外行为，完成功能扩展。
完整实现示例
下面以一个简单的文本处理场景为例，实现装饰器模式动态添加行为。基础功能是输出原始文本，后续需要动态添加大写转换、前后添加分隔符的功能。
1. 定义抽象组件
首先定义抽象组件接口，声明核心的行为方法：
// 抽象组件：定义文本处理的通用接口
class TextProcessor {
public:
virtual ~TextProcessor() = default;
// 处理文本的核心方法
virtual std::string process(const std::string& text) = 0;
};
2. 实现具体组件
实现原始的基础文本处理器，只完成最基础的文本返回功能：
// 具体组件：基础文本处理器，返回原始文本
class BasicTextProcessor : public TextProcessor {
public:
std::string process(const std::string& text) override {
return text;
}
};
3. 定义抽象装饰器
抽象装饰器继承抽象组件，同时持有抽象组件的指针，负责请求的转发：
// 抽象装饰器：持有被装饰对象的引用，转发基础请求
class TextDecorator : public TextProcessor {
protected:
// 持有被装饰的组件指针
TextProcessor* component;
public:
explicit TextDecorator(TextProcessor* comp) : component(comp) {}
virtual ~TextDecorator() {
delete component;
}
// 默认转发请求到被装饰对象
std::string process(const std::string& text) override {
return component->process(text);
}
};
4. 实现具体装饰器
分别实现两个具体装饰器，一个用于转换文本为大写，一个用于给文本添加前后分隔符：
#include <algorithm>
#include <cctype>
// 具体装饰器1：将文本转换为大写
class UpperCaseDecorator : public TextDecorator {
public:
explicit UpperCaseDecorator(TextProcessor* comp) : TextDecorator(comp) {}
std::string process(const std::string& text) override {
// 先调用被装饰对象的处理方法
std::string result = component->process(text);
// 添加大写转换的额外行为
std::transform(result.begin(), result.end(), result.begin(),
[](unsigned char c) { return std::toupper(c); });
return result;
}
};
// 具体装饰器2：给文本添加前后分隔符
class SeparatorDecorator : public TextDecorator {
private:
std::string separator;
public:
explicit SeparatorDecorator(TextProcessor* comp, const std::string& sep = "---")
: TextDecorator(comp), separator(sep) {}
std::string process(const std::string& text) override {
// 先调用被装饰对象的处理方法
std::string result = component->process(text);
// 添加前后分隔符的额外行为
return separator + result + separator;
}
};
5. 客户端调用验证
在客户端中动态组合装饰器，验证动态添加行为的效果：
#include <iostream>
int main() {
// 创建基础文本处理器
TextProcessor* processor = new BasicTextProcessor();
std::string testText = "hello decorator pattern";
// 只使用基础处理器
std::cout << "基础处理结果：" << processor->process(testText) << std::endl;
// 动态添加大写转换行为
processor = new UpperCaseDecorator(processor);
std::cout << "添加大写转换后：" << processor->process(testText) << std::endl;
// 再动态添加分隔符行为
processor = new SeparatorDecorator(processor);
std::cout << "再添加分隔符后：" << processor->process(testText) << std::endl;
// 也可以调整装饰顺序，先加分隔符再转大写
TextProcessor* anotherProcessor = new BasicTextProcessor();
anotherProcessor = new SeparatorDecorator(anotherProcessor);
anotherProcessor = new UpperCaseDecorator(anotherProcessor);
std::cout << "调整装饰顺序后：" << anotherProcessor->process(testText) << std::endl;
delete processor;
delete anotherProcessor;
return 0;
}
上述代码的输出结果如下：
基础处理结果：hello decorator pattern 添加大写转换后：HELLO DECORATOR PATTERN 再添加分隔符后：---HELLO DECORATOR PATTERN--- 调整装饰顺序后：---HELLO DECORATOR PATTERN---
装饰器模式的优缺点
优点
- 符合开闭原则，不需要修改原有类的代码就可以扩展功能，降低了代码耦合度。
- 比继承更加灵活，可以动态组合多种装饰器，实现不同的功能组合，避免了继承体系过于臃肿。
- 可以装饰不同的具体组件对象，复用装饰器的逻辑，减少重复代码。
缺点
- 会生成较多的装饰器类，如果功能扩展过多，会增加系统的复杂度。
- 多层装饰后，调试时调用链较长，排查问题相对困难。
- 如果装饰器的顺序有要求，需要开发者手动控制组合顺序，否则可能出现不符合预期的结果。
适用场景
当遇到以下场景时，可以优先考虑使用装饰器模式：
- 需要在不修改原有对象结构的前提下，动态给对象添加职责，且这些职责可以灵活组合、撤销。
- 用继承扩展功能会导致类数量爆炸，比如一个类有10种可选扩展功能，继承需要生成2^10种组合类，而装饰器只需要10个装饰器类即可。
- 需要给一个对象添加的功能存在排列组合的情况，不同组合对应不同的行为结果。