设计模式（七）-EW帮帮网

迭代器模式（Iterator Pattern）详解

一、核心概念

迭代器模式提供一种方法来顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。该模式将遍历逻辑封装在迭代器对象中，使聚合对象和遍历逻辑分离。

核心组件：

迭代器接口（Iterator）：定义访问和遍历元素的方法。
具体迭代器（Concrete Iterator）：实现迭代器接口，跟踪聚合对象中的当前位置。
聚合接口（Aggregate）：定义创建迭代器对象的方法。
具体聚合（Concrete Aggregate）：实现聚合接口，返回一个具体迭代器实例。

二、代码示例：自定义集合迭代器

场景：实现一个简单的数组集合，并为其提供迭代器支持。

#include <iostream>
#include <memory>

// 前向声明
template<typename T> class ArrayIterator;

// 迭代器接口
template<typename T>
class Iterator {
public:
    virtual ~Iterator() = default;
    virtual bool hasNext() const = 0;
    virtual T& next() = 0;
    virtual const T& next() const = 0;
};

// 聚合接口
template<typename T>
class Aggregate {
public:
    virtual ~Aggregate() = default;
    virtual std::unique_ptr<Iterator<T>> createIterator() const = 0;
    virtual size_t size() const = 0;
    virtual T& operator[](size_t index) = 0;
    virtual const T& operator[](size_t index) const = 0;
};

// 具体聚合：数组集合
template<typename T, size_t N>
class Array : public Aggregate<T> {
private:
    T data[N];
    size_t count = 0;

public:
    void add(const T& item) {
        if (count < N) {
            data[count++] = item;
        }
    }

    size_t size() const override { return count; }

    T& operator[](size_t index) override { return data[index]; }
    const T& operator[](size_t index) const override { return data[index]; }

    std::unique_ptr<Iterator<T>> createIterator() const override;
};

// 具体迭代器：数组迭代器
template<typename T, size_t N>
class ArrayIterator : public Iterator<T> {
private:
    const Array<T, N>* array;
    size_t position;

public:
    explicit ArrayIterator(const Array<T, N>* array) 
        : array(array), position(0) {}

    bool hasNext() const override {
        return position < array->size();
    }

    T& next() override {
        return (*array)[position++];
    }

    const T& next() const override {
        return (*array)[position++];
    }
};

// 实现createIterator方法
template<typename T, size_t N>
std::unique_ptr<Iterator<T>> Array<T, N>::createIterator() const {
    return std::make_unique<ArrayIterator<T, N>>(this);
}

// 客户端代码
int main() {
    Array<int, 5> numbers;
    numbers.add(10);
    numbers.add(20);
    numbers.add(30);

    // 使用迭代器遍历集合
    auto it = numbers.createIterator();
    while (it->hasNext()) {
        std::cout << it->next() << " ";
    }
    std::cout << std::endl;

    // C++范围for循环风格（需额外实现begin/end）
    // 此处省略具体实现...

    return 0;
}

三、迭代器模式的优势

分离遍历逻辑：
- 聚合对象的结构与遍历逻辑分离，符合单一职责原则。
简化聚合接口：
- 聚合类无需提供复杂的遍历接口，仅需创建迭代器。
支持多种遍历方式：
- 同一聚合对象可支持多种迭代器（如正向、反向、过滤迭代器）。
统一访问接口：
- 客户端通过统一的迭代器接口访问不同聚合结构，提高代码通用性。

四、实现变种

内部迭代器 vs 外部迭代器：
- 外部迭代器（如示例）：客户端控制迭代过程。
- 内部迭代器：迭代逻辑由迭代器自身控制，客户端提供回调函数。
双向迭代器：
- 支持向前和向后遍历（如 prev() 方法）。
流式迭代器：
- 支持惰性计算，适用于大数据集（如数据库查询结果）。
组合迭代器：
- 遍历组合模式中的树形结构（如文件系统）。

五、适用场景

隐藏聚合实现：
- 当需要隐藏聚合对象的内部结构（如数组、链表、树）时。
支持多种遍历方式：
- 如顺序遍历、随机访问、过滤遍历等。
统一遍历接口：
- 为不同类型的聚合对象提供一致的遍历接口。
简化客户端代码：
- 使客户端无需关心聚合对象的具体类型，专注于元素处理。

六、注意事项

迭代器失效：
- 在迭代过程中修改聚合对象可能导致迭代器失效（如删除元素）。
线程安全：
- 在多线程环境中，需确保迭代器的线程安全性。
与语言特性结合：
- C++ 标准库已提供 std::iterator 和容器迭代器，优先使用现有实现。
性能开销：
- 间接访问可能带来性能开销，需根据场景优化。

七、与其他模式的对比

与访问者模式的区别：
- 迭代器模式专注于遍历，访问者模式专注于元素处理。
与组合模式的结合：
- 组合模式的树形结构常使用迭代器模式遍历。
与生成器模式的关系：
- 生成器模式可用于动态生成迭代器所需的元素。

迭代器模式是处理聚合对象遍历的经典解决方案，通过将遍历逻辑封装在迭代器中，使代码更简洁、灵活且易于维护。在实际开发中，建议优先使用编程语言提供的内置迭代器（如 C++ 的 STL 迭代器），避免重复造轮子。

单例模式（Singleton Pattern）详解

一、核心概念

单例模式确保一个类只有一个实例，并提供一个全局访问点来获取该实例。该模式常用于需要全局唯一对象的场景，如配置管理器、日志记录器、数据库连接池等。

核心组件：

私有构造函数：防止外部直接实例化。
静态实例：持有类的唯一实例。
静态访问方法：提供全局访问点。

二、代码示例

1. 懒汉式（Lazy Initialization）

// 线程不安全版本（单线程环境）
class Singleton {
private:
    static Singleton* instance;
    Singleton() = default;             // 私有构造函数
    ~Singleton() = default;            // 私有析构函数
    Singleton(const Singleton&) = delete;         // 禁用拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁用赋值运算符

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {     // 第一次调用时初始化
            instance = new Singleton();
        }
        return instance;
    }
};

// 静态成员初始化
Singleton* Singleton::instance = nullptr;

2. 线程安全的懒汉式（双检锁）

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex_;
    Singleton() = default;

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {     // 第一次检查
            std::lock_guard<std::mutex> lock(mutex_);
            if (instance == nullptr) { // 第二次检查（锁内）
                instance = new Singleton();
            }
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex_;

3. 饿汉式（Eager Initialization）

class Singleton {
private:
    static const Singleton* instance;
    Singleton() = default;

public:
    static const Singleton* getInstance() {
        return instance;
    }
};

// 静态初始化（在main函数前完成）
const Singleton* Singleton::instance = new Singleton();

4. C++11 标准的 Meyers’ Singleton（推荐）

class Singleton {
private:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton instance;     // 线程安全的局部静态变量
        return instance;
    }
};

三、单例模式的优势

全局唯一性：
- 确保系统中一个类只有一个实例，便于资源控制。
全局访问点：
- 提供统一的访问方式，无需传递对象引用。
延迟初始化：
- 懒汉式实现支持延迟加载，节省资源。
严格控制访问：
- 通过私有构造函数和静态方法，严格控制实例化过程。

四、实现变种

多线程安全：
- 使用双检锁（DCLP）或 C++11 的局部静态变量保证线程安全。
可销毁单例：
- 添加静态销毁方法，确保正确释放资源。
模板单例：
- 使用模板实现通用单例基类，支持多个类复用单例逻辑。
参数化单例：
- 在首次调用时传入参数初始化单例。

五、适用场景

资源管理器：
- 如数据库连接池、文件系统管理器。
配置管理：
- 全局配置信息的读写。
日志系统：
- 集中记录系统运行状态。
GUI 组件：
- 如窗口管理器、对话框工厂。

六、注意事项

线程安全：
- 在多线程环境下必须保证实例创建的原子性（如 Meyers’ Singleton）。
内存泄漏：
- 动态分配的实例需确保正确释放（可使用智能指针或静态局部变量）。
反序列化问题：
- 单例类需防止通过反序列化创建新实例。
继承与多态：
- 单例类的子类可能导致多个实例，需谨慎设计。

七、与其他模式的对比

与静态类的区别：
- 单例是对象，支持继承和多态；静态类是全局方法集合。
与工厂模式的结合：
- 单例可作为工厂模式的工厂，创建其他对象。
与享元模式的区别：
- 单例强调唯一实例，享元强调对象复用。

单例模式是解决全局唯一对象需求的经典方案，但需谨慎使用，避免滥用导致代码耦合度高。在现代 C++ 中，推荐使用 Meyers’ Singleton 实现，既简洁又安全。

合成/聚合复用原则（CARP）详解

一、核心概念

合成/聚合复用原则（Composition/Aggregation Reuse Principle, CARP）主张：
“要尽量使用合成/聚合，而不是类继承来达到复用的目的”。

合成（Composition）：强拥有关系，部分与整体生命周期一致（如std::unique_ptr）。
聚合（Aggregation）：弱拥有关系，部分可独立于整体存在（如std::shared_ptr或引用）。

该原则强调通过对象组合实现复用，而非通过继承扩展类功能，以降低代码耦合度。

二、合成/聚合 vs 继承

维度	合成/聚合（推荐）	继承（需谨慎）
耦合度	低（对象间松耦合）	高（子类依赖父类实现）
灵活性	运行时动态组合，支持多态	编译时静态绑定，难以修改
复用粒度	细粒度（复用具体组件）	粗粒度（复用整个父类）
依赖可见性	仅依赖接口，不暴露内部实现	可能暴露父类非公共接口
设计模式	策略模式、装饰器模式、组合模式	模板方法模式、工厂方法模式

三、代码示例：交通工具与引擎

1. 反例：使用继承复用（高耦合）

// 父类：引擎
class Engine {
public:
    void start() { std::cout << "引擎启动" << std::endl; }
    void stop() { std::cout << "引擎停止" << std::endl; }
};

// 子类：汽车（继承引擎）
class Car : public Engine {
public:
    void drive() {
        start();  // 直接复用父类方法
        std::cout << "汽车行驶" << std::endl;
        stop();
    }
};

// 子类：飞机（继承引擎）
class Plane : public Engine {
public:
    void fly() {
        start();  // 直接复用父类方法
        std::cout << "飞机起飞" << std::endl;
        stop();
    }
};

问题：

继承导致Car和Plane与Engine强绑定，无法在运行时更换引擎类型。
若Engine修改接口，所有子类需同步修改。

2. 正例：使用聚合复用（低耦合）

// 接口：引擎
class IEngine {
public:
    virtual void start() = 0;
    virtual void stop() = 0;
    virtual ~IEngine() = default;
};

// 具体引擎：燃油引擎
class GasolineEngine : public IEngine {
public:
    void start() override { std::cout << "燃油引擎启动" << std::endl; }
    void stop() override { std::cout << "燃油引擎停止" << std::endl; }
};

// 具体引擎：电动引擎
class ElectricEngine : public IEngine {
public:
    void start() override { std::cout << "电动引擎启动" << std::endl; }
    void stop() override { std::cout << "电动引擎停止" << std::endl; }
};

// 交通工具（聚合引擎）
class Vehicle {
private:
    std::unique_ptr<IEngine> engine;  // 聚合：组合关系

public:
    explicit Vehicle(std::unique_ptr<IEngine> engine) 
        : engine(std::move(engine)) {}

    void setEngine(std::unique_ptr<IEngine> newEngine) {
        engine = std::move(newEngine);
    }

    void operate() {
        engine->start();
        std::cout << "交通工具运行" << std::endl;
        engine->stop();
    }
};

// 客户端代码
void clientCode() {
    // 使用燃油引擎
    auto car = Vehicle(std::make_unique<GasolineEngine>());
    car.operate();

    // 动态更换为电动引擎
    car.setEngine(std::make_unique<ElectricEngine>());
    car.operate();
}

优势：

通过聚合IEngine接口，Vehicle与具体引擎实现解耦。
支持运行时动态切换引擎类型，符合开闭原则。

四、合成/聚合复用的典型场景

策略模式（Strategy Pattern）
通过组合不同策略对象实现算法切换：

class SortStrategy {
public:
    virtual void sort(std::vector<int>& data) = 0;
};

class QuickSort : public SortStrategy { /* 实现 */ };
class MergeSort : public SortStrategy { /* 实现 */ };

class Sorter {
private:
    std::unique_ptr<SortStrategy> strategy;
public:
    void setStrategy(std::unique_ptr<SortStrategy> s) {
        strategy = std::move(s);
    }
    void performSort(std::vector<int>& data) {
        strategy->sort(data);
    }
};

装饰器模式（Decorator Pattern）
通过组合增强对象功能：

class Component {
public:
    virtual void operation() = 0;
};

class ConcreteComponent : public Component { /* 基础实现 */ };

class Decorator : public Component {
protected:
    std::shared_ptr<Component> component;
public:
    explicit Decorator(std::shared_ptr<Component> c) : component(c) {}
};

class LoggingDecorator : public Decorator {
public:
    void operation() override {
        std::cout << "Before operation" << std::endl;
        component->operation();
        std::cout << "After operation" << std::endl;
    }
};

五、使用指南

优先使用合成/聚合的场景：
- 需要动态改变对象行为时（如策略模式）。
- 复用细粒度组件而非整个类时。
- 避免继承导致的“脆弱基类问题”（修改基类可能破坏子类）。
继承的合理场景：
- 当子类是基类的“自然扩展”（如正方形是矩形的特例）。
- 复用基类的不变部分，扩展可变部分（如模板方法模式）。
- 实现多态接口（如抽象工厂模式）。
黄金法则：
- “HAS-A”关系优先用组合/聚合（如汽车有引擎）。
- “IS-A”关系谨慎用继承（如正方形是矩形）。

六、注意事项

过度组合导致的问题：
- 可能增加对象数量和管理复杂度。
- 需合理设计接口，避免接口膨胀。
与依赖倒置原则（DIP）结合：
- 聚合对象应依赖抽象接口而非具体实现，进一步降低耦合。
继承的替代方案：
- 委托（Delegation）：通过对象组合实现行为委托。
- 混入（Mixin）：通过模板或多重继承复用特定功能。

合成/聚合复用原则是实现低耦合、高内聚设计的关键，它通过对象组合替代继承，使系统更灵活、可维护和可扩展。在设计时，应根据具体场景权衡继承与组合的使用，避免过度依赖单一复用方式。

在C++中，无法在运行时动态确定子类继承自哪个基类。这是因为C++的继承关系是静态绑定的，必须在编译时明确指定。不过，你可以通过以下几种方式模拟运行时选择基类的行为：

一、为什么不能在运行时确定继承关系？

编译时确定内存布局：
子类的内存布局（包括基类子对象的偏移量）在编译时必须确定，否则无法进行对象访问。
静态类型系统限制：
C++的类型系统要求在编译时明确类的继承结构，以保证类型安全。

二、替代方案

1. 组合（Composition）替代继承

思路：在子类中包含基类指针，运行时动态选择基类实现。

#include <memory>

// 基接口
class Base {
public:
    virtual void doSomething() = 0;
    virtual ~Base() = default;
};

// 具体实现类A
class ConcreteA : public Base {
public:
    void doSomething() override { /* 实现A */ }
};

// 具体实现类B
class ConcreteB : public Base {
public:
    void doSomething() override { /* 实现B */ }
};

// 动态选择行为的类
class DynamicClass {
private:
    std::unique_ptr<Base> strategy;  // 组合基类指针

public:
    // 在运行时设置行为
    void setStrategy(std::unique_ptr<Base> strategy) {
        this->strategy = std::move(strategy);
    }

    // 委托调用
    void performAction() {
        if (strategy) strategy->doSomething();
    }
};

// 运行时选择示例
void runtimeSelection(bool condition) {
    DynamicClass obj;
    if (condition) {
        obj.setStrategy(std::make_unique<ConcreteA>());
    } else {
        obj.setStrategy(std::make_unique<ConcreteB>());
    }
    obj.performAction();  // 根据condition选择不同实现
}

2. 模板（编译时多态）

思路：通过模板参数在编译时选择基类。

// 基类A
class BaseA {
public:
    void method() { /* 基类A的实现 */ }
};

// 基类B
class BaseB {
public:
    void method() { /* 基类B的实现 */ }
};

// 模板子类：编译时选择基类
template<typename BaseType>
class Derived : public BaseType {
public:
    void callBaseMethod() {
        this->method();  // 调用所选基类的方法
    }
};

// 编译时选择示例
void compileTimeSelection(bool condition) {
    if (condition) {
        Derived<BaseA> obj;  // 继承自BaseA
        obj.callBaseMethod();
    } else {
        Derived<BaseB> obj;  // 继承自BaseB
        obj.callBaseMethod();
    }
}

3. 多重继承 + 运行时类型切换

思路：继承所有可能的基类，运行时通过接口选择具体行为。

// 接口A
class InterfaceA {
public:
    virtual void actionA() = 0;
};

// 接口B
class InterfaceB {
public:
    virtual void actionB() = 0;
};

// 实现类同时继承两个接口
class MultiBase : public InterfaceA, public InterfaceB {
public:
    void actionA() override { /* 实现A */ }
    void actionB() override { /* 实现B */ }
};

// 运行时选择接口
void runtimeInterfaceSelection(bool useA) {
    MultiBase obj;
    if (useA) {
        InterfaceA* ptr = &obj;
        ptr->actionA();  // 使用接口A
    } else {
        InterfaceB* ptr = &obj;
        ptr->actionB();  // 使用接口B
    }
}

4. 动态加载插件（运行时动态绑定）

思路：通过插件系统在运行时加载不同的实现库。

// 公共接口
class PluginInterface {
public:
    virtual void execute() = 0;
    virtual ~PluginInterface() = default;
};

// 插件工厂（简化版）
class PluginFactory {
public:
    static std::unique_ptr<PluginInterface> createPlugin(const std::string& name) {
        // 实际实现中通过动态库加载
        if (name == "A") return std::make_unique<PluginA>();
        if (name == "B") return std::make_unique<PluginB>();
        return nullptr;
    }
};

// 运行时加载插件
void loadPluginAtRuntime(const std::string& pluginName) {
    auto plugin = PluginFactory::createPlugin(pluginName);
    if (plugin) plugin->execute();
}

三、各方案对比

方案	实现方式	绑定时机	灵活性	复杂度
组合替代继承	持有基类指针	运行时	高	中
模板	模板参数选择基类	编译时	中	低
多重继承	继承所有基类，选接口使用	运行时	中	高
动态加载插件	运行时加载动态库	运行时	极高	高

四、总结

C++无法真正实现运行时继承，因为继承关系必须在编译时确定。
组合（策略模式）是最常用的替代方案，它通过委托机制在运行时动态选择行为。
模板方案适用于编译时已知的选择，可提供零成本抽象。
动态加载插件则适用于需要最大灵活性的场景（如插件系统）。

根据具体需求，选择合适的替代方案来模拟“运行时选择基类”的行为。

设计模式（七）

迭代器模式（Iterator Pattern）详解

一、核心概念

二、代码示例：自定义集合迭代器

三、迭代器模式的优势

四、实现变种

五、适用场景

六、注意事项

七、与其他模式的对比

单例模式（Singleton Pattern）详解

一、核心概念

二、代码示例

1. 懒汉式（Lazy Initialization）

2. 线程安全的懒汉式（双检锁）

3. 饿汉式（Eager Initialization）

4. C++11 标准的 Meyers’ Singleton（推荐）

三、单例模式的优势

四、实现变种

五、适用场景

六、注意事项

七、与其他模式的对比

合成/聚合复用原则（CARP）详解

一、核心概念

二、合成/聚合 vs 继承

三、代码示例：交通工具与引擎

1. 反例：使用继承复用（高耦合）

2. 正例：使用聚合复用（低耦合）

四、合成/聚合复用的典型场景

五、使用指南

六、注意事项

一、为什么不能在运行时确定继承关系？

二、替代方案

1. 组合（Composition）替代继承

2. 模板（编译时多态）

3. 多重继承 + 运行时类型切换

4. 动态加载插件（运行时动态绑定）

三、各方案对比

四、总结

网站公告

今日签到

热门文章

最新发布