C++装饰模式：动态扩展对象功能的艺术与实践

1. 装饰模式初探：给对象"穿衣服"的艺术

第一次听说装饰模式时，我脑海中浮现的是给圣诞树挂彩灯的场景。就像我们可以在不改变树本身的情况下，通过添加各种装饰品来改变它的外观和功能，装饰模式也遵循类似的理念。这个模式在C++中特别有用，因为它允许我们在运行时动态地给对象添加新功能，而不需要修改原有类的代码。

记得我刚入行时接手过一个图形编辑器项目，当时需要在基础图形上叠加多种效果（如边框、阴影、透明度）。最初的做法是通过继承创建各种组合类（如CircleWithBorderAndShadow），结果类爆炸式增长，维护起来苦不堪言。直到后来重构使用了装饰模式，才真正体会到这个模式的精妙之处。

2. 装饰模式的核心结构解析

2.1 UML类图与角色划分

装饰模式的经典结构包含四个关键角色：

1. Component（抽象组件）：定义对象的接口，可以是抽象类或接口。在我们的图形编辑器例子中，就是基础的Graphic类。

cpp复制class Graphic {
public:
    virtual ~Graphic() = default;
    virtual void draw() const = 0;
};

2. ConcreteComponent（具体组件）：实现Component接口的具体对象。比如Circle和Rectangle类。

cpp复制class Circle : public Graphic {
public:
    void draw() const override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

3. Decorator（抽象装饰器）：继承自Component，并持有一个Component指针。这是模式的核心。

cpp复制class GraphicDecorator : public Graphic {
protected:
    Graphic* wrapped;
public:
    explicit GraphicDecorator(Graphic* g) : wrapped(g) {}
    void draw() const override {
        if (wrapped) wrapped->draw();
    }
};

4. ConcreteDecorator（具体装饰器）：实现具体的装饰功能。比如BorderDecorator。

cpp复制class BorderDecorator : public GraphicDecorator {
public:
    explicit BorderDecorator(Graphic* g) : GraphicDecorator(g) {}
    
    void draw() const override {
        GraphicDecorator::draw();
        addBorder();
    }
    
private:
    void addBorder() const {
        std::cout << "Adding border decoration" << std::endl;
    }
};

2.2 模式的工作原理

装饰模式的关键在于层层包裹。当我们创建一个装饰器时，它内部会持有一个被装饰对象的引用。调用装饰器的方法时，会先调用被装饰对象的方法，然后再执行自己的附加操作。这种结构形成了类似"俄罗斯套娃"的嵌套关系。

cpp复制Graphic* circle = new Circle();
Graphic* borderedCircle = new BorderDecorator(circle);
Graphic* shadowedBorderedCircle = new ShadowDecorator(borderedCircle);

shadowedBorderedCircle->draw();
// 输出:
// Drawing a circle
// Adding border decoration
// Adding shadow effect

3. 装饰模式的C++实现细节

3.1 内存管理的最佳实践

在C++中实现装饰模式时，内存管理是需要特别注意的问题。由于装饰器持有被装饰对象的指针，我们需要明确所有权关系。现代C++中推荐使用智能指针：

cpp复制class GraphicDecorator : public Graphic {
protected:
    std::unique_ptr<Graphic> wrapped;
public:
    explicit GraphicDecorator(std::unique_ptr<Graphic>&& g) 
        : wrapped(std::move(g)) {}
    // ...
};

// 使用示例
auto circle = std::make_unique<Circle>();
auto borderedCircle = std::make_unique<BorderDecorator>(std::move(circle));

重要提示：装饰器模式中，装饰器必须接管被装饰对象的所有权，否则容易出现内存泄漏或双重释放问题。

3.2 支持多种方法的装饰器

实际项目中，我们的组件通常会有多个方法。装饰器需要确保对所有方法都提供一致的装饰行为：

cpp复制class AdvancedGraphic {
public:
    virtual ~AdvancedGraphic() = default;
    virtual void draw() const = 0;
    virtual void resize(float factor) = 0;
    virtual std::string description() const = 0;
};

class AdvancedDecorator : public AdvancedGraphic {
protected:
    std::unique_ptr<AdvancedGraphic> wrapped;
public:
    explicit AdvancedDecorator(std::unique_ptr<AdvancedGraphic>&& g)
        : wrapped(std::move(g)) {}
        
    void draw() const override { if (wrapped) wrapped->draw(); }
    void resize(float factor) override { if (wrapped) wrapped->resize(factor); }
    std::string description() const override { 
        return wrapped ? wrapped->description() : "null"; 
    }
};

3.3 装饰器的组合与顺序

装饰器的应用顺序会影响最终结果。比如先加边框再加阴影，与先加阴影再加边框，效果可能不同：

cpp复制// 顺序1：边框->阴影
auto circle = std::make_unique<Circle>();
auto decoratedCircle = std::make_unique<ShadowDecorator>(
    std::make_unique<BorderDecorator>(std::move(circle))
);

// 顺序2：阴影->边框
auto circle2 = std::make_unique<Circle>();
auto decoratedCircle2 = std::make_unique<BorderDecorator>(
    std::make_unique<ShadowDecorator>(std::move(circle2))
);

4. 装饰模式在实际项目中的应用场景

4.1 图形界面开发

在GUI开发中，装饰模式几乎无处不在：

• 为窗口添加滚动条、边框
• 为文本添加格式化（加粗、斜体）
• 为控件添加工具提示、动画效果

cpp复制// 创建一个带滚动条和边框的窗口
std::unique_ptr<Window> basicWindow = std::make_unique<BasicWindow>();
std::unique_ptr<Window> decoratedWindow = std::make_unique<BorderDecorator>(
    std::make_unique<ScrollDecorator>(std::move(basicWindow))
);

4.2 I/O流处理

C++标准库中的std::istream和std::ostream就是装饰模式的经典应用。我们可以通过std::istringstream、std::ifstream等来装饰基础流：

cpp复制#include <fstream>
#include <zlib.h>

class CompressedStream : public std::ostream {
    // 实现压缩装饰器
};

// 使用示例
std::ofstream file("data.bin");
CompressedStream compressedFile(&file);
compressedFile << "Compressed data";

4.3 游戏开发中的装备系统

在角色扮演游戏中，角色的装备系统非常适合用装饰模式实现：

cpp复制class Character {
public:
    virtual int attack() const = 0;
    virtual ~Character() = default;
};

class Warrior : public Character {
public:
    int attack() const override { return 10; }
};

class Equipment : public Character {
protected:
    std::unique_ptr<Character> character;
public:
    explicit Equipment(std::unique_ptr<Character>&& c) 
        : character(std::move(c)) {}
    int attack() const override { return character->attack(); }
};

class Sword : public Equipment {
public:
    using Equipment::Equipment;
    int attack() const override { 
        return Equipment::attack() + 5; 
    }
};

class Shield : public Equipment {
public:
    using Equipment::Equipment;
    int attack() const override {
        return Equipment::attack() - 2; // 盾牌降低攻击力但增加防御
    }
};

// 创建装备了剑和盾牌的战士
auto warrior = std::make_unique<Warrior>();
auto equippedWarrior = std::make_unique<Shield>(
    std::make_unique<Sword>(std::move(warrior))
);
std::cout << "Attack power: " << equippedWarrior->attack(); // 输出13

5. 装饰模式的优缺点与替代方案

5.1 装饰模式的优势

1. 比继承更灵活：可以在运行时动态添加或移除功能，而继承是静态的
2. 避免类爆炸：不需要为每种功能组合创建子类
3. 单一职责原则：每个装饰器只关注一个特定功能
4. 开闭原则：可以扩展功能而不修改现有代码

5.2 装饰模式的局限性

1. 小对象增多：大量装饰器会创建许多小对象，可能影响性能
2. 装饰顺序敏感：不同装饰顺序可能导致不同结果，需要谨慎管理
3. 移除装饰困难：一旦装饰，很难移除特定装饰器
4. 初始化复杂：多层装饰可能导致初始化代码难以阅读

5.3 何时考虑替代方案

在某些情况下，其他模式可能更适合：

• 策略模式：当需要完全改变对象行为时
• 适配器模式：当需要转换接口时
• 组合模式：当需要处理树形结构时

6. 装饰模式的高级应用技巧

6.1 装饰器工厂

为了简化装饰器的创建过程，可以实现装饰器工厂：

cpp复制enum DecorationType { BORDER, SHADOW, GLOW };

std::unique_ptr<Graphic> decorateGraphic(
    std::unique_ptr<Graphic>&& graphic,
    const std::vector<DecorationType>& decorations)
{
    for (auto type : decorations) {
        switch (type) {
            case BORDER:
                graphic = std::make_unique<BorderDecorator>(std::move(graphic));
                break;
            case SHADOW:
                graphic = std::make_unique<ShadowDecorator>(std::move(graphic));
                break;
            case GLOW:
                graphic = std::make_unique<GlowDecorator>(std::move(graphic));
                break;
        }
    }
    return graphic;
}

// 使用示例
auto circle = std::make_unique<Circle>();
auto decorated = decorateGraphic(std::move(circle), {BORDER, SHADOW});

6.2 带参数的装饰器

装饰器可以接受额外参数来定制行为：

cpp复制class ColorBorderDecorator : public GraphicDecorator {
    std::string color;
public:
    ColorBorderDecorator(std::unique_ptr<Graphic>&& g, std::string c)
        : GraphicDecorator(std::move(g)), color(std::move(c)) {}
    
    void draw() const override {
        GraphicDecorator::draw();
        std::cout << "Adding " << color << " border" << std::endl;
    }
};

// 使用示例
auto rect = std::make_unique<Rectangle>();
auto redBorderedRect = std::make_unique<ColorBorderDecorator>(
    std::move(rect), "red"
);

6.3 装饰器的调试技巧

当装饰器嵌套层数较多时，调试可能变得困难。可以添加调试信息：

cpp复制class DebugDecorator : public GraphicDecorator {
public:
    using GraphicDecorator::GraphicDecorator;
    
    void draw() const override {
        std::cout << "Before decorated draw()" << std::endl;
        GraphicDecorator::draw();
        std::cout << "After decorated draw()" << std::endl;
    }
};

// 在装饰链中插入调试装饰器
auto circle = std::make_unique<Circle>();
auto debugged = std::make_unique<DebugDecorator>(std::move(circle));

7. 装饰模式与其他模式的协作

7.1 装饰模式与工厂模式结合

通过工厂模式创建装饰器可以隐藏复杂的装饰逻辑：

cpp复制class GraphicFactory {
public:
    std::unique_ptr<Graphic> createDecoratedCircle(
        bool withBorder, bool withShadow) const
    {
        auto circle = std::make_unique<Circle>();
        
        if (withBorder) {
            circle = std::make_unique<BorderDecorator>(std::move(circle));
        }
        
        if (withShadow) {
            circle = std::make_unique<ShadowDecorator>(std::move(circle));
        }
        
        return circle;
    }
};

7.2 装饰模式与组合模式结合

装饰器可以装饰组合对象，实现更复杂的功能：

cpp复制class GraphicGroup : public Graphic {
    std::vector<std::unique_ptr<Graphic>> children;
public:
    void add(std::unique_ptr<Graphic> g) {
        children.push_back(std::move(g));
    }
    
    void draw() const override {
        for (const auto& child : children) {
            child->draw();
        }
    }
};

// 装饰整个组合对象
auto group = std::make_unique<GraphicGroup>();
group->add(std::make_unique<Circle>());
group->add(std::make_unique<Rectangle>());

auto decoratedGroup = std::make_unique<BorderDecorator>(std::move(group));

7.3 装饰模式与访问者模式结合

访问者模式可以帮助遍历复杂的装饰结构：

cpp复制class GraphicVisitor {
public:
    virtual void visitCircle(const Circle&) = 0;
    virtual void visitRectangle(const Rectangle&) = 0;
    virtual void visitBorderDecorator(const BorderDecorator&) = 0;
    // ...其他具体装饰器
};

class Graphic {
public:
    virtual void accept(GraphicVisitor& visitor) = 0;
    // ...
};

// 在具体类中实现accept
void Circle::accept(GraphicVisitor& visitor) { visitor.visitCircle(*this); }

void BorderDecorator::accept(GraphicVisitor& visitor) {
    visitor.visitBorderDecorator(*this);
    if (wrapped) wrapped->accept(visitor);
}

8. 性能考量与优化

8.1 内存开销分析

装饰模式会引入额外的内存开销，主要体现在：

• 每个装饰器都是一个独立对象
• 虚函数表指针开销
• 动态分配的内存管理开销

对于性能敏感的场景，可以考虑：

• 使用内存池预分配装饰器对象
• 限制装饰层数
• 将多个装饰功能合并到一个装饰器中

8.2 虚函数调用开销

装饰模式中频繁的虚函数调用可能影响性能。优化方法包括：

• 使用CRTP模式减少虚函数调用
• 对性能关键路径考虑静态装饰
• 使用内联装饰器

cpp复制// CRTP装饰器示例
template <typename T>
class CRTPDecorator : public T {
protected:
    T& wrapped;
public:
    explicit CRTPDecorator(T& w) : wrapped(w) {}
    void draw() const override {
        wrapped.draw();
        // 装饰逻辑
    }
};

8.3 测量装饰器性能

使用C++11的<chrono>测量装饰器性能影响：

cpp复制auto start = std::chrono::high_resolution_clock::now();

// 测试带装饰的调用
for (int i = 0; i < 100000; ++i) {
    decoratedGraphic->draw();
}

auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << "Decorated call took " << duration.count() << " microseconds\n";

9. C++20/23中的现代实现

9.1 使用概念约束装饰器

C++20的概念可以帮助我们更好地约束装饰器：

cpp复制template <typename T>
concept GraphicType = requires(T t) {
    { t.draw() } -> std::same_as<void>;
};

template <GraphicType T>
class ModernDecorator {
    T wrapped;
public:
    explicit ModernDecorator(T&& w) : wrapped(std::move(w)) {}
    
    void draw() const {
        wrapped.draw();
        // 装饰逻辑
    }
};

9.2 使用std::variant实现静态装饰

C++17的std::variant可以实现静态多态的装饰器：

cpp复制using GraphicVariant = std::variant<Circle, Rectangle>;

class VariantDecorator {
    GraphicVariant wrapped;
public:
    explicit VariantDecorator(GraphicVariant&& g) : wrapped(std::move(g)) {}
    
    void draw() const {
        std::visit([](auto&& g) { g.draw(); }, wrapped);
        // 装饰逻辑
    }
};

9.3 使用协程实现异步装饰

C++20协程可以用于实现异步装饰器：

cpp复制AsyncTask<Image> downloadAndDecorate(std::string url) {
    auto rawImage = co_await downloadImage(url);
    auto decorated = applyDecorations(rawImage);
    co_return decorated;
}

10. 测试装饰模式的策略

10.1 单元测试装饰器

使用Google Test等框架测试装饰器：

cpp复制TEST(DecoratorTest, BorderDecoratorAddsBorder) {
    auto circle = std::make_unique<Circle>();
    auto borderedCircle = std::make_unique<BorderDecorator>(std::move(circle));
    
    testing::internal::CaptureStdout();
    borderedCircle->draw();
    std::string output = testing::internal::GetCapturedStdout();
    
    EXPECT_TRUE(output.find("Adding border decoration") != std::string::npos);
}

10.2 模拟装饰器依赖

使用模拟对象测试装饰器：

cpp复制class MockGraphic : public Graphic {
public:
    MOCK_METHOD(void, draw, (), (const override));
};

TEST(DecoratorTest, DecoratorCallsWrappedDraw) {
    auto mock = std::make_unique<MockGraphic>();
    EXPECT_CALL(*mock, draw()).Times(1);
    
    auto decorator = std::make_unique<BorderDecorator>(std::move(mock));
    decorator->draw();
}

10.3 集成测试装饰器组合

测试多个装饰器的组合效果：

cpp复制TEST(DecoratorTest, MultipleDecoratorsWorkTogether) {
    auto circle = std::make_unique<Circle>();
    auto decorated = std::make_unique<ShadowDecorator>(
        std::make_unique<BorderDecorator>(std::move(circle))
    );
    
    testing::internal::CaptureStdout();
    decorated->draw();
    std::string output = testing::internal::GetCapturedStdout();
    
    EXPECT_TRUE(output.find("Drawing a circle") != std::string::npos);
    EXPECT_TRUE(output.find("Adding border decoration") != std::string::npos);
    EXPECT_TRUE(output.find("Adding shadow effect") != std::string::npos);
}

11. 实际项目中的经验教训

11.1 装饰器与对象生命周期

在长期运行的项目中，装饰器的生命周期管理尤为重要。我曾遇到过一个内存泄漏问题，原因是装饰器链中的某个节点没有被正确释放。解决方案是：

1. 统一使用智能指针管理装饰器链
2. 避免在装饰器之间共享对象
3. 为装饰器实现清晰的析构逻辑

11.2 装饰器的序列化挑战

当需要序列化装饰器链时，会遇到类型信息丢失的问题。解决方案包括：

1. 为每个装饰器分配唯一类型ID
2. 实现统一的序列化接口
3. 使用工厂模式重建装饰器链

cpp复制class SerializableDecorator : public Graphic {
public:
    virtual std::string getType() const = 0;
    virtual void serialize(std::ostream& out) const = 0;
    static std::unique_ptr<Graphic> deserialize(std::istream& in);
};

11.3 避免过度装饰

装饰模式虽然灵活，但过度使用会导致：

• 代码难以理解
• 调试困难
• 性能下降

经验法则是：当装饰层数超过3层时，考虑重构方案。可以使用外观模式封装常用装饰组合。

12. 装饰模式在标准库中的应用

12.1 STL流装饰器

C++标准库中的流装饰器：

cpp复制#include <iomanip>

// 设置输出格式的装饰器
std::cout << std::setw(10) << std::setfill('*') << 42;

12.2 智能指针作为装饰器

std::unique_ptr和std::shared_ptr本质上也是装饰器，它们在不改变被管理对象接口的情况下添加了内存管理功能。

12.3 范围装饰器

C++20的范围库使用装饰器模式添加各种视图：

cpp复制#include <ranges>

auto evenNumbers = std::views::filter([](int n){ return n % 2 == 0; });
for (int n : numbers | evenNumbers) {
    // 处理偶数
}

13. 跨平台开发中的装饰模式

13.1 平台特定装饰

在不同平台上，可以使用装饰器添加平台特定功能：

cpp复制class PlatformWindow {
public:
    virtual void show() = 0;
    virtual ~PlatformWindow() = default;
};

class WindowsWindow : public PlatformWindow { /*...*/ };
class MacWindow : public PlatformWindow { /*...*/ };

class WindowDecorator : public PlatformWindow {
protected:
    std::unique_ptr<PlatformWindow> window;
public:
    explicit WindowDecorator(std::unique_ptr<PlatformWindow>&& w)
        : window(std::move(w)) {}
    void show() override { if (window) window->show(); }
};

class WindowsThemeDecorator : public WindowDecorator {
public:
    using WindowDecorator::WindowDecorator;
    void show() override {
        applyWindowsTheme();
        WindowDecorator::show();
    }
};

13.2 网络层装饰

在网络库中，可以使用装饰器添加加密、压缩等功能：

cpp复制class NetworkStream {
public:
    virtual void send(const std::vector<uint8_t>& data) = 0;
    virtual std::vector<uint8_t> receive() = 0;
    virtual ~NetworkStream() = default;
};

class EncryptedStream : public NetworkStream {
    std::unique_ptr<NetworkStream> stream;
    EncryptionKey key;
public:
    EncryptedStream(std::unique_ptr<NetworkStream>&& s, EncryptionKey k)
        : stream(std::move(s)), key(std::move(k)) {}
    
    void send(const std::vector<uint8_t>& data) override {
        auto encrypted = encrypt(data, key);
        stream->send(encrypted);
    }
    
    std::vector<uint8_t> receive() override {
        auto data = stream->receive();
        return decrypt(data, key);
    }
};

14. 装饰模式的反模式与误用

14.1 装饰器与继承的混淆

常见错误是用装饰器替代本应使用继承的场景。判断标准是：

• 如果需要改变对象的核心行为，用继承
• 如果只是添加辅助功能，用装饰器

14.2 过度复杂的装饰链

当装饰链过长时，应考虑：

• 合并相关装饰器
• 使用工厂封装常用组合
• 改用策略模式

14.3 忽略装饰顺序的影响

不同装饰顺序可能导致不同行为。解决方案：

• 明确文档记录装饰顺序约定
• 使用工厂控制装饰顺序
• 实现顺序无关的装饰器

15. 从装饰模式到面向切面编程(AOP)

装饰模式是AOP的基础。在C++中，我们可以构建简单的AOP框架：

cpp复制template <typename Func>
class Aspect {
    Func f;
public:
    explicit Aspect(Func func) : f(func) {}
    
    template <typename... Args>
    auto operator()(Args&&... args) {
        before();
        auto result = f(std::forward<Args>(args)...);
        after();
        return result;
    }
    
private:
    void before() { /* 前置处理 */ }
    void after() { /* 后置处理 */ }
};

// 使用示例
auto loggedFunc = Aspect([](int x, int y) { return x + y; });
int result = loggedFunc(2, 3);

16. 装饰模式与SOLID原则

16.1 单一职责原则(SRP)

装饰模式完美体现SRP，每个装饰器只负责一个特定功能。

16.2 开闭原则(OCP)

装饰模式允许扩展功能而不修改现有代码，是OCP的典范。

16.3 里氏替换原则(LSP)

装饰器是其组件类型的子类型，可以无缝替换原始组件。

16.4 接口隔离原则(ISP)

装饰器保持与被装饰对象相同的接口，不会强迫客户端依赖不需要的方法。

16.5 依赖倒置原则(DIP)

高层模块依赖于抽象接口，装饰器和具体组件都实现这些接口。

17. 元编程与装饰模式

17.1 编译时装饰器

使用模板元编程实现编译时装饰：

cpp复制template <typename T>
class CompileTimeDecorator : public T {
public:
    void draw() const override {
        T::draw();
        std::cout << "Compile-time decoration" << std::endl;
    }
};

// 使用
CompileTimeDecorator<Circle> decoratedCircle;
decoratedCircle.draw();

17.2 属性装饰器

使用C++特性实现属性装饰：

cpp复制[[decorate("border")]]
void drawCircle() {
    // ...
}

// 通过反射或预处理实现装饰逻辑

17.3 基于策略的装饰

使用策略模式实现灵活装饰：

cpp复制template <typename DrawingPolicy>
class PolicyDecorator : public Graphic {
    DrawingPolicy policy;
    std::unique_ptr<Graphic> wrapped;
public:
    PolicyDecorator(std::unique_ptr<Graphic>&& g, DrawingPolicy p)
        : wrapped(std::move(g)), policy(std::move(p)) {}
    
    void draw() const override {
        policy.beforeDraw();
        if (wrapped) wrapped->draw();
        policy.afterDraw();
    }
};

18. 函数式风格的装饰器

18.1 使用std::function装饰函数

cpp复制using DrawFunction = std::function<void()>;

auto addBorder(DrawFunction f) {
    return [f] {
        f();
        std::cout << "Adding border" << std::endl;
    };
}

// 使用
auto drawCircle = [] { std::cout << "Drawing circle" << std::endl; };
auto decorated = addBorder(drawCircle);
decorated();

18.2 组合多个装饰器

cpp复制template <typename F>
auto decorate(F f) {
    return [f](auto... decorators) {
        return (decorators(f), ...);
    };
}

auto drawSquare = [] { std::cout << "Drawing square" << std::endl; };
auto withBorder = [](auto f) { 
    return [f] { f(); std::cout << "With border" << std::endl; }; 
};
auto withShadow = [](auto f) { 
    return [f] { f(); std::cout << "With shadow" << std::endl; }; 
};

auto decorated = decorate(drawSquare)(withBorder, withShadow);
decorated();

19. 性能敏感场景的优化装饰器

19.1 静态多态装饰器

使用CRTP避免虚函数开销：

cpp复制template <typename T>
class StaticDecorator : public T {
public:
    void draw() const {
        T::draw();
        // 装饰逻辑
    }
};

// 使用
StaticDecorator<Circle> decoratedCircle;
decoratedCircle.draw();

19.2 内存连续的装饰器

对于性能关键路径，可以使用连续内存布局：

cpp复制class DecoratorChain {
    std::vector<std::function<void()>> decorations;
    std::function<void()> base;
public:
    void addDecoration(std::function<void()> dec) {
        decorations.push_back(dec);
    }
    
    void execute() const {
        for (const auto& dec : decorations) {
            dec();
        }
        base();
    }
};

19.3 无分配装饰器

避免动态内存分配：

cpp复制template <typename T, typename D>
class StackDecorator {
    T wrapped;
    D decorator;
public:
    template <typename... Args>
    StackDecorator(Args&&... args) 
        : wrapped(std::forward<Args>(args)...) {}
    
    void draw() const {
        decorator.before();
        wrapped.draw();
        decorator.after();
    }
};

20. 装饰模式的未来演进

随着C++标准的发展，装饰模式可能会有新的实现方式：

1. 反射支持：C++未来的反射特性可能简化装饰器的创建和组合
2. 模式匹配：更强大的模式匹配可以简化装饰器逻辑的处理
3. 契约编程：装饰器可以结合契约，验证前置和后置条件

在多年使用装饰模式的经验中，我发现它最强大的地方在于其组合性。就像搭积木一样，我们可以通过简单的装饰器组合出复杂的行为。但也要警惕过度装饰带来的复杂性，记住：最简单的解决方案往往是最好的。