浅析设计模式-23种设计模式剖析

倚楼盼风雨2026-04-10 15:26

《Design Patterns: Elements of Reusable Object-Oriented Software》

------ 尝试构建高效、可维护和可扩展的方式来构建软件系统。

设计原则：

  1. 单一职责原则（SRP）：一个类只做一件事

  2. 开闭原则（OCP）：对扩展开放，对修改关闭

  3. 里氏替换原则（LSP）：子类应能替换父类

  4. 接口隔离原则（ISP）：避免臃肿接口

  5. 依赖倒置原则（DIP）：依赖抽象而非实现

经典的软件设计模式主要分为三大类：创建型、结构型和行为型，以下是它们的分类：

复制代码 
  设计模式（23种）
  │
  ├── 创建型模式（5种）─ 如何创建对象
  │   ├── 单例模式
  │   ├── 工厂方法模式
  │   ├── 抽象工厂模式
  │   ├── 建造者模式
  │   └── 原型模式
  │
  ├── 结构型模式（7种）─ 如何组合对象
  │   ├── 适配器模式
  │   ├── 桥接模式
  │   ├── 组合模式
  │   ├── 装饰器模式
  │   ├── 外观模式
  │   ├── 享元模式
  │   └── 代理模式
  │
  └── 行为型模式（11种）─ 如何分配职责
      ├── 责任链模式
      ├── 命令模式
      ├── 解释器模式
      ├── 迭代器模式
      ├── 中介者模式
      ├── 备忘录模式
      ├── 观察者模式
      ├── 状态模式
      ├── 策略模式
      ├── 模板方法模式
      └── 访问者模式
1.创建型模式（Creational Patterns）

**目的：**控制对象的创建过程，解耦对象的实例化逻辑，隐藏对象创建的复杂性

  • 单例模式（Singleton）

    确保一个类只有一个实例 ，并提供一个全局访问点来访问该实例。

    • 常规版本：
    cpp 复制代码 
    #ifndef SINGLETON_H
#define SINGLETON_H

//////////////////////////////////////////////////////////////////////////
// class Singleton 
//////////////////////////////////////////////////////////////////////////
#include "AX_API/AX_Mutex.h"

template <class T> 
class Singleton  
{
public:
	static T* instance()
	{ 
		if ( 0 == s_instance )
		{
			s_mutex.acquire();
			if ( 0 == s_instance )
			{
				s_instance = new T;
			}
			s_mutex.release();
		}

		return s_instance;
	}

	static void unInstance()
	{
		if ( 0 != s_instance )
		{
			s_mutex.acquire();
			if ( 0 != s_instance )
			{
				delete s_instance;
				s_instance = 0;
			}
			s_mutex.release();
		}
	}

protected:
	Singleton() {}
	virtual ~Singleton() {}

private:
	Singleton(const Singleton<T> &); //不实现 
	Singleton<T>& operator= (const Singleton<T> &); //不实现

	static T* s_instance;
	static AX_Mutex s_mutex;
};

template <class T>
T* Singleton<T>::s_instance = 0;

template <class T>
AX_Mutex Singleton<T>::s_mutex;

//////////////////////////////////////////////////////////////////////////
// class SingletonStatic
//////////////////////////////////////////////////////////////////////////
template <class T> 
class SingletonStatic  
{
public:
	static T* instance()
	{
		return &s_instance;
	}

protected:
	SingletonStatic() {}
	virtual ~SingletonStatic() {}

private:
	SingletonStatic(const SingletonStatic<T> &); //不实现 
	SingletonStatic<T>& operator= (const SingletonStatic<T> &); //不实现

	static T s_instance;
};

template <class T>
T SingletonStatic<T>::s_instance;

//////////////////////////////////////////////////////////////////////////

#endif
    • 线程安全实现（C++11以后）
    cpp 复制代码 
    #include <iostream>
#include <mutex>

class Singleton {
private:
    static std::unique_ptr<Singleton> instance;
    static std::once_flag initFlag;
    
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }
    
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
public:
    // 获取单例实例（线程安全）
    static Singleton& getInstance() {
        std::call_once(initFlag, []() {
            instance.reset(new Singleton());
        });
        return *instance;
    }
    
    void doSomething() {
        std::cout << "Doing something" << std::endl;
    }
    
    ~Singleton() {
        std::cout << "Singleton destroyed" << std::endl;
    }
};

// 初始化静态成员
std::unique_ptr<Singleton> Singleton::instance;
std::once_flag Singleton::initFlag;

// 客户端代码
int main() {
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();
    
    std::cout << "s1 address: " << &s1 << std::endl;
    std::cout << "s2 address: " << &s2 << std::endl;
    
    s1.doSomething();
    
    return 0;
}
    • Meyers' Singleton（最简洁的线程安全实现）
    cpp 复制代码 
    #include <iostream>

class Singleton {
private:
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }
    
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
public:
    // 获取单例实例（线程安全）
    static Singleton& getInstance() {
        static Singleton instance;  // 局部静态变量
        return instance;
    }
    
    void doSomething() {
        std::cout << "Doing something" << std::endl;
    }
    
    ~Singleton() {
        std::cout << "Singleton destroyed" << std::endl;
    }
};

// 客户端代码
int main() {
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();
    
    std::cout << "s1 address: " << &s1 << std::endl;
    std::cout << "s2 address: " << &s2 << std::endl;
    
    s1.doSomething();
    
    return 0;
}

  • 简单工厂模式 (Simple Factory Pattern)

    简单工厂通过一个工厂类来创建对象，而不是在客户端代码中直接实例化具体类。它也被称为静态工厂方法模式。

    • 主要组成部分

      • 工厂类 (Factory): 负责创建具体产品对象的类
      • 抽象产品 (Product): 定义产品的接口
      • 具体产品 (Concrete Product): 实现抽象产品接口的具体类

    • 代码示例：

      cpp 复制代码 
      #include <iostream>
#include <string>
#include <memory>

// 抽象产品类
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 工厂类
class SimpleFactory {
public:
    // 工厂方法
    static std::unique_ptr<Product> createProduct(const std::string& type) {
        if (type == "A") {
            return std::make_unique<ConcreteProductA>();
        } else if (type == "B") {
            return std::make_unique<ConcreteProductB>();
        }
        throw std::invalid_argument("Unknown product type");
    }
};

// 客户端代码
int main() {
    try {
        // 创建产品A
        auto productA = SimpleFactory::createProduct("A");
        productA->operation();  // 输出: ConcreteProductA operation
        
        // 创建产品B
        auto productB = SimpleFactory::createProduct("B");
        productB->operation();  // 输出: ConcreteProductB operation
        
        // 测试未知类型
        // auto productC = SimpleFactory::createProduct("C"); // 抛出异常
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    
    return 0;
}

  • 工厂方法模式（Factory Method）

    提供了一种创建对象的接口，但允许子类决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。

    • 主要组成成分：

      • 抽象产品 (Product): 定义产品的接口
      • 具体产品 (Concrete Product): 实现抽象产品接口的具体类
      • 抽象工厂 (Creator): 声明工厂方法，返回一个产品对象
      • 具体工厂 (Concrete Creator): 重写工厂方法以返回具体产品实例

    • 代码示例：

      cpp 复制代码 
      #include <iostream>
#include <memory>

// 抽象产品类
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 抽象工厂类
class Creator {
public:
    virtual ~Creator() = default;
    
    // 工厂方法
    virtual std::unique_ptr<Product> factoryMethod() const = 0;
    
    void someOperation() const {
        auto product = factoryMethod();
        product->operation();
    }
};

// 具体工厂A
class ConcreteCreatorA : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() const override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂B
class ConcreteCreatorB : public Creator {
public:
    std::unique_ptr<Product> factoryMethod() const override {
        return std::make_unique<ConcreteProductB>();
    }
};

// 客户端代码
int main() {
    std::cout << "Factory Method Pattern in C++" << std::endl;
    
    // 使用具体工厂A
    std::unique_ptr<Creator> creatorA = std::make_unique<ConcreteCreatorA>();
    creatorA->someOperation();  // 输出: ConcreteProductA operation
    
    // 使用具体工厂B
    std::unique_ptr<Creator> creatorB = std::make_unique<ConcreteCreatorB>();
    creatorB->someOperation();  // 输出: ConcreteProductB operation
    
    return 0;
}

  • 抽象工厂模式 (Abstract Factory Pattern)

    提供一个接口用于创建相关或依赖对象家族，而无需指定具体类。

    • 主要组成部分

      • 抽象工厂 (Abstract Factory): 声明创建一系列产品的方法
      • 具体工厂 (Concrete Factory): 实现抽象工厂的接口，创建具体产品
      • 抽象产品 (Abstract Product): 为产品家族中的每种产品声明接口
      • 具体产品 (Concrete Product): 实现抽象产品接口的具体类
      • 客户端 (Client): 使用抽象工厂和抽象产品接口

    • 代码示例

      cpp 复制代码 
      #include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() = default;
    virtual void operationA() = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ProductA1 operation" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ProductA2 operation" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() = default;
    virtual void operationB() = 0;
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ProductB1 operation" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ProductB2 operation" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() = default;
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB2>();
    }
};

// 客户端代码
void clientCode(const AbstractFactory& factory) {
    auto productA = factory.createProductA();
    auto productB = factory.createProductB();
    
    productA->operationA();
    productB->operationB();
}

int main() {
    std::cout << "Client: Testing client code with the first factory type:\n";
    ConcreteFactory1 factory1;
    clientCode(factory1);
    
    std::cout << "\nClient: Testing client code with the second factory type:\n";
    ConcreteFactory2 factory2;
    clientCode(factory2);
    
    return 0;
}

  • 创建者

    • 主要组成部分
    • 代码示例

  • 原型

    • 主要组成部分
    • 代码示例
2.结构型模式

关注类和对象的组合，帮助确保系统中的类和对象能够灵活地组成更大的结构

  • 适配器
    • 主要组成部分
    • 代码示例
  • 装饰器
    • 主要组成部分
    • 代码示例
  • 代理
    • 主要组成部分
    • 代码示例
  • 组合
    • 主要组成部分
    • 代码示例
  • 外观
    • 主要组成部分
    • 代码示例
  • 桥接
    • 主要组成部分
    • 代码示例
  • 享元
    • 主要组成部分
    • 代码示例
3.行为型模式

关注类和对象之间的交互和职责分配

  • 观察者
    • 主要组成部分
    • 代码示例
  • 策略
    • 主要组成部分
    • 代码示例
  • 命令
    • 主要组成部分
    • 代码示例
  • 模板方法
    • 主要组成部分
    • 代码示例
  • 责任链
    • 主要组成部分
    • 代码示例
  • 状态
    • 主要组成部分
    • 代码示例
  • 访问者（Visitor Pattern）：分离算法与对象结构
    • 主要组成部分
    • 代码示例
  • 中介者（Mediator Pattern）：集中对象交互
    • 主要组成部分
    • 代码示例
  • 迭代器（Iterator Pattern）：提供遍历集合的统一方式
    • 主要组成部分
    • 代码示例
  • 备忘录（Memento Pattern）：捕获对象状态已便恢复
    • 主要组成部分
    • 代码示例
  • 解释器（Interpreter Pattern）：定义与语法规则
    • 主要组成部分
    • 代码示例
相关推荐
UXbot1 天前
AI原型设计工具评测：从创意到交互式Demo，5款产品全面解析
前端·ui·设计模式·ai·ai编程·原型模式
橘子编程1 天前
GoF 23 种设计模式完整知识总结与使用教程
java·c语言·开发语言·python·设计模式
UrSpecial1 天前
设计模式：模板方法模式
设计模式·模板方法模式
如来神掌十八式1 天前
设计模式之装饰器模式
java·设计模式
qqxhb2 天前
26｜Agent 设计模式：ReAct、Plan-and-Solve 与反射
设计模式·react模式·plan-and-solve·reflection模式
hssfscv2 天前
软件设计师下午题六——Java的各种设计模式
java·算法·设计模式
zhaoshuzhaoshu2 天前
设计模式之创建型设计模式详细解析(含示例)
单例模式·设计模式·架构
Momentary_SixthSense3 天前
设计模式之工厂模式
java·开发语言·设计模式
Java码农也是农3 天前
Multi-Agent 系统设计模式
设计模式·agent·multi-agent
热门推荐
01GitHub 镜像站点02一周AI热点速览（2026.03.31-04.06）：GPT-6曝光、谷歌开源Gemma 4、资本狂飙与模型军备竞赛03基于 Docker 部署 Hermes Agent 并接入飞书机器人的完整指南04OpenClaw 请求超时 llm request timed out 怎么解决？3 种方案实测，附完整排查流程05VMware Workstation Pro 17 虚拟机完整安装教程（2026最新）06CodeBuddy与WorkBuddy深度对比：腾讯两款AI工具差异及实操指南07实测！Gemma 4 成功跑在安卓手机上：离线 AI 助手终于来了08AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析09Oh My Codex 快速使用指南10开发者环境配置：用 Ollama 实现本地大模型部署(附下载慢的解决方案