迭代器模式（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++ 标准库已提供
性能开销：
- 间接访问可能带来性能开销，需根据场景优化。
七、与其他模式的对比
与访问者模式的区别：
- 迭代器模式专注于遍历，访问者模式专注于元素处理。
与组合模式的结合：
- 组合模式的树形结构常使用迭代器模式遍历。
与生成器模式的关系：
- 生成器模式可用于动态生成迭代器所需的元素。
迭代器模式是处理聚合对象遍历的经典解决方案，通过将遍历逻辑封装在迭代器中，使代码更简洁、灵活且易于维护。在实际开发中，建议优先使用编程语言提供的内置迭代器（如 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++无法真正实现运行时继承，因为继承关系必须在编译时确定。
- 组合（策略模式）是最常用的替代方案，它通过委托机制在运行时动态选择行为。
- 模板方案适用于编译时已知的选择，可提供零成本抽象。
- 动态加载插件则适用于需要最大灵活性的场景（如插件系统）。
根据具体需求，选择合适的替代方案来模拟“运行时选择基类”的行为。