面向对象与设计模式第二节：设计模式实战

第三章：面向对象与设计模式

第二节：设计模式实战

设计模式是软件工程中的一项重要实践，它为解决常见的设计问题提供了经过验证的解决方案。本课将深入探讨几种常见的设计模式，并通过实际案例分析其在项目中的应用。

1. 每种设计模式的详尽解释与代码示例

设计模式分为三大类：创建型模式、结构型模式和行为型模式。以下是每种模式的详细解释与代码示例。

1.1 创建型模式

创建型模式专注于对象的创建过程，提供了创建对象的多种方式，降低了系统的复杂度。

1.1.1 单例模式

单例模式确保某个类仅有一个实例，并提供一个全局访问点。它非常适合于需要全局访问的对象，如配置管理器或数据库连接。

实现步骤：

将构造函数设为私有。
提供一个静态方法，用于获取单例实例。
在静态方法中检查实例是否存在，如果不存在，则创建一个。

代码示例：

class Singleton {
private:static Singleton* instance;// 私有构造函数，防止外部创建实例Singleton() {}public:static Singleton* getInstance() {if (!instance) {instance = new Singleton();}return instance;}void showMessage() {std::cout << "Hello from Singleton!" << std::endl;}
};// 初始化静态成员
Singleton* Singleton::instance = nullptr;

使用场景：

在应用程序中需要唯一实例的地方，例如日志记录、配置管理。

优缺点：

优点：控制实例数量，减少内存开销。
缺点：可能导致全局状态的问题，不利于单元测试。

实际应用：在大型企业应用中，单例模式被广泛用于数据库连接池的管理，确保应用程序中的数据库连接都是通过一个管理实例来处理，从而提高资源的利用率和降低并发访问的问题。

扩展讨论：为了确保线程安全，可以使用懒汉式或饿汉式的单例实现方法，或者使用std::call_once来确保线程安全的实例创建。

1.1.2 工厂模式

工厂模式定义了一个接口，用于创建对象，但将具体实现推迟到子类中。它提供了一种封装对象创建的方式，使得客户端不需要了解具体的创建过程。

实现步骤：

定义一个产品接口。
创建具体的产品类实现该接口。
定义一个工厂类，用于创建具体产品的实例。

代码示例：

class Product {
public:virtual void use() = 0;
};class ConcreteProductA : public Product {
public:void use() override {std::cout << "Using Product A" << std::endl;}
};class ConcreteProductB : public Product {
public:void use() override {std::cout << "Using Product B" << std::endl;}
};class Creator {
public:virtual Product* factoryMethod() = 0;void someOperation() {Product* product = factoryMethod();product->use();}
};class ConcreteCreatorA : public Creator {
public:Product* factoryMethod() override {return new ConcreteProductA();}
};class ConcreteCreatorB : public Creator {
public:Product* factoryMethod() override {return new ConcreteProductB();}
};

使用场景：

在创建对象时，客户端无需知道具体的类，只需调用工厂方法。

优缺点：

优点：代码解耦，易于扩展。
缺点：增加了系统的复杂度。

实际应用：在电商平台中，不同的支付方式（如信用卡、PayPal）可以使用工厂模式创建，使得添加新支付方式时，只需新增一个工厂类，而无需更改客户端代码。

扩展讨论：工厂模式的变种，如抽象工厂模式，允许创建多个系列的产品，适用于复杂的对象创建场景。

1.2 结构型模式

结构型模式关注类和对象的组合，以形成更大的结构，常用的有适配器模式、装饰者模式等。

1.2.1 适配器模式

适配器模式允许将一个类的接口转换成客户端所期望的另一种接口，使得不兼容的接口能够协同工作。

实现步骤：

定义目标接口。
实现适配器类，内部持有被适配者的实例。
在适配器类中实现目标接口的方法，调用被适配者的方法。

代码示例：

class Target {
public:virtual void request() {std::cout << "Target request" << std::endl;}
};class Adaptee {
public:void specificRequest() {std::cout << "Specific request" << std::endl;}
};class Adapter : public Target {
private:Adaptee* adaptee;public:Adapter(Adaptee* a) : adaptee(a) {}void request() override {adaptee->specificRequest();}
};

使用场景：

当需要集成已有系统而无法修改其代码时，例如引入第三方库。

优缺点：

优点：提高了系统的灵活性。
缺点：增加了类的数量，可能导致系统复杂性提高。

实际应用：在项目中，如果需要集成不同的第三方库（如支付接口），适配器模式可以帮助统一接口，使得调用方式一致，便于后期维护和更换。

扩展讨论：适配器模式可以与装饰者模式结合使用，以同时实现接口适配和功能增强。

1.2.2 装饰者模式

装饰者模式允许动态地给一个对象添加一些额外的职责，提供比继承更灵活的扩展方式。

实现步骤：

定义一个组件接口。
创建具体的组件类实现该接口。
创建装饰者类，持有一个组件实例，并在其方法中添加功能。

代码示例：

class Component {
public:virtual std::string operation() {return "Base Component";}
};class Decorator : public Component {
protected:Component* component;public:Decorator(Component* c) : component(c) {}std::string operation() override {return component->operation() + " + Decorated";}
};

使用场景：

需要在运行时添加功能时，例如用户界面元素的动态装饰。

优缺点：

优点：增强了系统的灵活性和可扩展性。
缺点：增加了复杂度，可能导致过多的小类。

实际应用：在GUI框架中，可以使用装饰者模式为按钮添加边框、阴影等效果，而无需创建多个子类。

扩展讨论：装饰者模式与策略模式的结合可以实现功能的多样化，通过不同的装饰组合，产生不同的行为。

1.3 行为型模式

行为型模式主要关注对象之间的交互和职责分配，常见的有策略模式、观察者模式等。

1.3.1 策略模式

策略模式定义了一系列算法，并将每一个算法封装起来，使它们可以互换使用。

实现步骤：

定义一个策略接口。
实现多个具体策略类。
定义上下文类，持有一个策略实例，并在运行时根据需要选择策略。

代码示例：

class Strategy {
public:virtual void algorithm() = 0;
};class ConcreteStrategyA : public Strategy {
public:void algorithm() override {std::cout << "Algorithm A" << std::endl;}
};class ConcreteStrategyB : public Strategy {
public:void algorithm() override {std::cout << "Algorithm B" << std::endl;}
};class Context {
private:Strategy* strategy;public:Context(Strategy* s) : strategy(s) {}void executeStrategy() {strategy->algorithm();}
};

使用场景：