设计模式（七）

迭代器模式（Iterator Pattern）详解

一、核心概念

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

核心组件：

1. 迭代器接口（Iterator）：定义访问和遍历元素的方法。
2. 具体迭代器（Concrete Iterator）：实现迭代器接口，跟踪聚合对象中的当前位置。
3. 聚合接口（Aggregate）：定义创建迭代器对象的方法。
4. 具体聚合（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;
}

三、迭代器模式的优势

1. 分离遍历逻辑：

   • 聚合对象的结构与遍历逻辑分离，符合单一职责原则。

2. 简化聚合接口：

   • 聚合类无需提供复杂的遍历接口，仅需创建迭代器。

3. 支持多种遍历方式：

   • 同一聚合对象可支持多种迭代器（如正向、反向、过滤迭代器）。

4. 统一访问接口：

   • 客户端通过统一的迭代器接口访问不同聚合结构，提高代码通用性。

四、实现变种

1. 内部迭代器 vs 外部迭代器：

   • 外部迭代器（如示例）：客户端控制迭代过程。
   • 内部迭代器：迭代逻辑由迭代器自身控制，客户端提供回调函数。

2. 双向迭代器：

   • 支持向前和向后遍历（如 prev() 方法）。

3. 流式迭代器：

   • 支持惰性计算，适用于大数据集（如数据库查询结果）。

4. 组合迭代器：

   • 遍历组合模式中的树形结构（如文件系统）。

五、适用场景

1. 隐藏聚合实现：

   • 当需要隐藏聚合对象的内部结构（如数组、链表、树）时。

2. 支持多种遍历方式：

   • 如顺序遍历、随机访问、过滤遍历等。

3. 统一遍历接口：

   • 为不同类型的聚合对象提供一致的遍历接口。

4. 简化客户端代码：

   • 使客户端无需关心聚合对象的具体类型，专注于元素处理。

六、注意事项

1. 迭代器失效：

   • 在迭代过程中修改聚合对象可能导致迭代器失效（如删除元素）。

2. 线程安全：

   • 在多线程环境中，需确保迭代器的线程安全性。

3. 与语言特性结合：

   • C++ 标准库已提供 std::iterator 和容器迭代器，优先使用现有实现。

4. 性能开销：

   • 间接访问可能带来性能开销，需根据场景优化。

七、与其他模式的对比

1. 与访问者模式的区别：

   • 迭代器模式专注于遍历，访问者模式专注于元素处理。

2. 与组合模式的结合：

   • 组合模式的树形结构常使用迭代器模式遍历。

3. 与生成器模式的关系：

   • 生成器模式可用于动态生成迭代器所需的元素。

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

单例模式（Singleton Pattern）详解

一、核心概念

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

核心组件：

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

二、代码示例

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;}
};

三、单例模式的优势

1. 全局唯一性：

   • 确保系统中一个类只有一个实例，便于资源控制。

2. 全局访问点：

   • 提供统一的访问方式，无需传递对象引用。

3. 延迟初始化：

   • 懒汉式实现支持延迟加载，节省资源。

4. 严格控制访问：

   • 通过私有构造函数和静态方法，严格控制实例化过程。

四、实现变种

1. 多线程安全：

   • 使用双检锁（DCLP）或 C++11 的局部静态变量保证线程安全。

2. 可销毁单例：

   • 添加静态销毁方法，确保正确释放资源。

3. 模板单例：

   • 使用模板实现通用单例基类，支持多个类复用单例逻辑。

4. 参数化单例：

   • 在首次调用时传入参数初始化单例。

五、适用场景

1. 资源管理器：

   • 如数据库连接池、文件系统管理器。

2. 配置管理：

   • 全局配置信息的读写。

3. 日志系统：

   • 集中记录系统运行状态。

4. GUI 组件：

   • 如窗口管理器、对话框工厂。

六、注意事项

1. 线程安全：

   • 在多线程环境下必须保证实例创建的原子性（如 Meyers’ Singleton）。

2. 内存泄漏：

   • 动态分配的实例需确保正确释放（可使用智能指针或静态局部变量）。

3. 反序列化问题：

   • 单例类需防止通过反序列化创建新实例。

4. 继承与多态：

   • 单例类的子类可能导致多个实例，需谨慎设计。

七、与其他模式的对比

1. 与静态类的区别：

   • 单例是对象，支持继承和多态；静态类是全局方法集合。

2. 与工厂模式的结合：

   • 单例可作为工厂模式的工厂，创建其他对象。

3. 与享元模式的区别：

   • 单例强调唯一实例，享元强调对象复用。

单例模式是解决全局唯一对象需求的经典方案，但需谨慎使用，避免滥用导致代码耦合度高。在现代 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与具体引擎实现解耦。
• 支持运行时动态切换引擎类型，符合开闭原则。

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

1. 策略模式（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);}
   };
   

2. 装饰器模式（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;}
   };
   

五、使用指南

1. 优先使用合成/聚合的场景：

   • 需要动态改变对象行为时（如策略模式）。
   • 复用细粒度组件而非整个类时。
   • 避免继承导致的“脆弱基类问题”（修改基类可能破坏子类）。

2. 继承的合理场景：

   • 当子类是基类的“自然扩展”（如正方形是矩形的特例）。
   • 复用基类的不变部分，扩展可变部分（如模板方法模式）。
   • 实现多态接口（如抽象工厂模式）。

3. 黄金法则：

   • “HAS-A”关系优先用组合/聚合（如汽车有引擎）。
   • “IS-A”关系谨慎用继承（如正方形是矩形）。

六、注意事项

1. 过度组合导致的问题：

   • 可能增加对象数量和管理复杂度。
   • 需合理设计接口，避免接口膨胀。

2. 与依赖倒置原则（DIP）结合：

   • 聚合对象应依赖抽象接口而非具体实现，进一步降低耦合。

3. 继承的替代方案：

   • 委托（Delegation）：通过对象组合实现行为委托。
   • 混入（Mixin）：通过模板或多重继承复用特定功能。

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

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

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

1. 编译时确定内存布局：
   子类的内存布局（包括基类子对象的偏移量）在编译时必须确定，否则无法进行对象访问。

2. 静态类型系统限制：
   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;  // 继承自BaseAobj.callBaseMethod();} else {Derived<BaseB> obj;  // 继承自BaseBobj.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++无法真正实现运行时继承，因为继承关系必须在编译时确定。
• 组合（策略模式）是最常用的替代方案，它通过委托机制在运行时动态选择行为。
• 模板方案适用于编译时已知的选择，可提供零成本抽象。
• 动态加载插件则适用于需要最大灵活性的场景（如插件系统）。

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