template mixin对装饰器设计模式的实现

Template Mixin 在 Modern C++ 中确实可以用于实现 装饰器设计模式（Decorator Pattern），但它的应用范围更广，装饰模式只是它的一个具体实现场景。

✅ 什么是 Template Mixin？

Template Mixin 是一种基于模板继承的设计模式，通常利用 CRTP（Curiously Recurring Template Pattern）、模板参数包（variadic templates） 以及 多继承，将多个功能模块（mixin）动态组合，形成具有多种行为的对象。

与传统的继承模型不同，mixin 不依赖于某个特定的继承层级，而是通过模板参数将行为在 编译期 组合，提供了更灵活、轻量的代码复用方式。

🎨 Template Mixin vs. 装饰器模式

📌 如何使用 Template Mixin 实现装饰器模式？

1️⃣ 传统装饰器实现

这是使用 面向对象方式 实现的经典装饰器。

#include <iostream>
#include <memory>

// 基础组件接口
class Component {
public:
    virtual void execute() const = 0;
    virtual ~Component() = default;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void execute() const override {
        std::cout << "ConcreteComponent executing\n";
    }
};

// 装饰器基类
class Decorator : public Component {
protected:
    std::shared_ptr<Component> component;
public:
    Decorator(std::shared_ptr<Component> comp) : component(std::move(comp)) {}
    void execute() const override {
        component->execute();
    }
};

// 添加日志功能的装饰器
class LoggingDecorator : public Decorator {
public:
    using Decorator::Decorator;
    void execute() const override {
        std::cout << "[Logging] Before execution\n";
        Decorator::execute();
        std::cout << "[Logging] After execution\n";
    }
};

// 使用示例
int main() {
    auto component = std::make_shared<ConcreteComponent>();
    auto loggingDecorator = std::make_shared<LoggingDecorator>(component);
    loggingDecorator->execute();
}

✅ 输出：

[Logging] Before execution
ConcreteComponent executing
[Logging] After execution

2️⃣ 使用 Template Mixin 实现

使用模板实现的多层装饰器，避免了动态分配和运行时多态。

#include <iostream>

// 基础类
template <typename Derived>
class Component {
public:
    void execute() const {
        static_cast<const Derived*>(this)->executeImpl();
    }
};

// 核心功能
class ConcreteComponent : public Component<ConcreteComponent> {
public:
    void executeImpl() const {
        std::cout << "ConcreteComponent executing\n";
    }
};

// Mixin: 添加日志功能
template <typename Base>
class LoggingMixin : public Base {
public:
    template <typename... Args>
    LoggingMixin(Args&&... args) : Base(std::forward<Args>(args)...) {}

    void executeImpl() const {
        std::cout << "[Logging] Before execution\n";
        Base::executeImpl();
        std::cout << "[Logging] After execution\n";
    }
};

// Mixin: 性能监控
template <typename Base>
class ProfilingMixin : public Base {
public:
    template <typename... Args>
    ProfilingMixin(Args&&... args) : Base(std::forward<Args>(args)...) {}

    void executeImpl() const {
        auto start = std::chrono::high_resolution_clock::now();
        Base::executeImpl();
        auto end = std::chrono::high_resolution_clock::now();
        std::cout << "[Profiling] Execution time: "
                  << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count()
                  << " µs\n";
    }
};

// 使用多层 Mixin
using DecoratedComponent = LoggingMixin<ProfilingMixin<ConcreteComponent>>;

int main() {
    DecoratedComponent component;
    component.execute();
}

✅ 输出：

[Logging] Before execution
ConcreteComponent executing
[Profiling] Execution time: 10 µs
[Logging] After execution

🔥 Template Mixin 优势分析

1️⃣ 零开销（Zero-Overhead）

由于模板代码在编译期生成，没有虚函数，因此不会引入运行时多态的开销，适合对 性能要求高 的场景（如驱动、图形渲染、音视频处理）。

2️⃣ 高度灵活的功能组合

可以自由组合任意多个 Mixin，生成不同的功能扩展，例如：

using AdvancedComponent = LoggingMixin<ProfilingMixin<ConcreteComponent>>;

3️⃣ 支持 CRTP（Curiously Recurring Template Pattern）

CRTP 是实现 Mixin 的关键技术，通过 Derived 类型参数，让子类在模板中调用自身实现。

📚 适用场景对比

🎯 总结

1. Template Mixin 是 Modern C++ 提供的一种强大机制，能在 编译期 灵活组合行为，避免了传统装饰器的 动态多态 和 性能瓶颈。

2. 什么时候使用哪种方案？

   • 动态场景：选择传统 装饰器模式（如 GUI 组件、网络过滤器）。
   • 静态场景：使用 Template Mixin（如 嵌入式系统、驱动开发、音视频流处理）。

3. 两种模式 各有优劣，根据项目需求选择最合适的设计模式。