当前位置： 首页 > news >正文

四种对象型创建模式：抽象工厂、 build模式、原型ProtoType与单例模式

news 2025/10/1 7:02:11

1. 抽象工厂模式 (Abstract Factory)

组件框图

┌─────────────────┐         ┌──────────────────┐
│   Client        │         │ AbstractFactory  │
├─────────────────┤         ├──────────────────┤
│                 │───────>│+createProductA()  │
│                 │         │+createProductB()  │
└─────────────────┘         └──────────────────┘△┌─────────────────┼─────────────────┐┌──────────┴──────────┐            ┌──────────┴──────────┐│ ConcreteFactory1    │            │ ConcreteFactory2    │├─────────────────────┤            ├─────────────────────┤│+createProductA()    │            │+createProductA()    ││+createProductB()    │            │+createProductB()    │└─────────────────────┘            └─────────────────────┘│                                  │┌─────────┼─────────┐              ┌─────────┼─────────┐┌──────┴─────┐ ┌─┴──────┐        ┌──────┴─────┐ ┌─┴──────┐│ ProductA1  │ │ProductB1│        │ ProductA2  │ │ProductB2│└────────────┘ └─────────┘        └────────────┘ └─────────┘

详细描述

问题：
需要创建一系列相关或依赖的对象，但不希望指定具体的类。例如，需要创建跨平台的UI组件。

解决方案：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

效果：

  • 优点：保证产品系列的兼容性，易于交换产品系列

  • 缺点：难以支持新种类的产品

Python实现

from abc import ABC, abstractmethod# 抽象产品A
class Button(ABC):@abstractmethoddef render(self):pass# 抽象产品B
class Checkbox(ABC):@abstractmethoddef paint(self):pass# 具体产品A1
class WindowsButton(Button):def render(self):return "渲染Windows风格按钮"# 具体产品B1
class WindowsCheckbox(Checkbox):def paint(self):return "绘制Windows风格复选框"# 具体产品A2
class MacButton(Button):def render(self):return "渲染macOS风格按钮"# 具体产品B2
class MacCheckbox(Checkbox):def paint(self):return "绘制macOS风格复选框"# 抽象工厂
class GUIFactory(ABC):@abstractmethoddef create_button(self) -> Button:pass@abstractmethoddef create_checkbox(self) -> Checkbox:pass# 具体工厂1
class WindowsFactory(GUIFactory):def create_button(self) -> Button:return WindowsButton()def create_checkbox(self) -> Checkbox:return WindowsCheckbox()# 具体工厂2
class MacFactory(GUIFactory):def create_button(self) -> Button:return MacButton()def create_checkbox(self) -> Checkbox:return MacCheckbox()# 客户端代码
class Application:def __init__(self, factory: GUIFactory):self.factory = factoryself.button = Noneself.checkbox = Nonedef create_ui(self):self.button = self.factory.create_button()self.checkbox = self.factory.create_checkbox()def paint(self):print(self.button.render())print(self.checkbox.paint())# 使用
if __name__ == "__main__":print("=== Windows UI ===")windows_factory = WindowsFactory()app1 = Application(windows_factory)app1.create_ui()app1.paint()print("\n=== macOS UI ===")mac_factory = MacFactory()app2 = Application(mac_factory)app2.create_ui()app2.paint()

C++实现

#include <iostream>
#include <memory>
#include <string>// 抽象产品A
class Button {
public:virtual ~Button() = default;virtual std::string render() = 0;
};// 抽象产品B
class Checkbox {
public:virtual ~Checkbox() = default;virtual std::string paint() = 0;
};// 具体产品A1
class WindowsButton : public Button {
public:std::string render() override {return "渲染Windows风格按钮";}
};// 具体产品B1
class WindowsCheckbox : public Checkbox {
public:std::string paint() override {return "绘制Windows风格复选框";}
};// 具体产品A2
class MacButton : public Button {
public:std::string render() override {return "渲染macOS风格按钮";}
};// 具体产品B2
class MacCheckbox : public Checkbox {
public:std::string paint() override {return "绘制macOS风格复选框";}
};// 抽象工厂
class GUIFactory {
public:virtual ~GUIFactory() = default;virtual std::unique_ptr<Button> createButton() = 0;virtual std::unique_ptr<Checkbox> createCheckbox() = 0;
};// 具体工厂1
class WindowsFactory : public GUIFactory {
public:std::unique_ptr<Button> createButton() override {return std::make_unique<WindowsButton>();}std::unique_ptr<Checkbox> createCheckbox() override {return std::make_unique<WindowsCheckbox>();}
};// 具体工厂2
class MacFactory : public GUIFactory {
public:std::unique_ptr<Button> createButton() override {return std::make_unique<MacButton>();}std::unique_ptr<Checkbox> createCheckbox() override {return std::make_unique<MacCheckbox>();}
};// 客户端代码
class Application {
private:std::unique_ptr<GUIFactory> factory;std::unique_ptr<Button> button;std::unique_ptr<Checkbox> checkbox;public:Application(std::unique_ptr<GUIFactory> factory) : factory(std::move(factory)) {}void createUI() {button = this->factory->createButton();checkbox = this->factory->createCheckbox();}void paint() {std::cout << button->render() << std::endl;std::cout << checkbox->paint() << std::endl;}
};// 使用
int main() {std::cout << "=== Windows UI ===" << std::endl;auto windowsFactory = std::make_unique<WindowsFactory>();Application app1(std::move(windowsFactory));app1.createUI();app1.paint();std::cout << "\n=== macOS UI ===" << std::endl;auto macFactory = std::make_unique<MacFactory>();Application app2(std::move(macFactory));app2.createUI();app2.paint();return 0;
}

2. 建造者模式 (Builder)

组件框图

┌─────────────────┐         ┌──────────────────┐
│   Director      │         │    Builder       │
├─────────────────┤         ├──────────────────┤
│+construct()     │───────>│+buildPartA()     │
│                 │         │+buildPartB()     │
│                 │         │+getResult()      │
└─────────────────┘         └──────────────────┘△┌─────────────────┼─────────────────┐┌──────────┴──────────┐            ┌──────────┴──────────┐│ ConcreteBuilder1    │            │ ConcreteBuilder2    │├─────────────────────┤            ├─────────────────────┤│+buildPartA()        │            │+buildPartA()        ││+buildPartB()        │            │+buildPartB()        ││+getResult()         │            │+getResult()         │└─────────────────────┘            └─────────────────────┘│                                  │┌─────────┴─────────┐              ┌─────────┴─────────┐│     Product1      │              │     Product2      │└───────────────────┘              └───────────────────┘

详细描述

问题：
创建复杂对象时，构造过程复杂且可能有多个步骤，或者需要创建不同表示的对象。

解决方案：
将复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

效果：

  • 优点：封装了复杂对象的创建过程，可以精细控制构建过程

  • 缺点：增加了系统复杂度，需要多个具体建造者类

Python实现

from abc import ABC, abstractmethod
from typing import List# 产品类
class Computer:def __init__(self):self.parts: List[str] = []def add(self, part: str):self.parts.append(part)def list_parts(self):return f"计算机配置: {', '.join(self.parts)}"def __str__(self):return self.list_parts()# 抽象建造者
class ComputerBuilder(ABC):def __init__(self):self.computer = Computer()@abstractmethoddef build_cpu(self):pass@abstractmethoddef build_memory(self):pass@abstractmethoddef build_storage(self):pass@abstractmethoddef build_graphics_card(self):passdef get_computer(self) -> Computer:computer = self.computerself.computer = Computer()  # 重置用于下次构建return computer# 具体建造者 - 游戏电脑
class GamingComputerBuilder(ComputerBuilder):def build_cpu(self):self.computer.add("Intel i9-13900K CPU")def build_memory(self):self.computer.add("32GB DDR5 RAM")def build_storage(self):self.computer.add("2TB NVMe SSD")def build_graphics_card(self):self.computer.add("NVIDIA RTX 4090")# 具体建造者 - 办公电脑
class OfficeComputerBuilder(ComputerBuilder):def build_cpu(self):self.computer.add("Intel i5-12400 CPU")def build_memory(self):self.computer.add("16GB DDR4 RAM")def build_storage(self):self.computer.add("512GB SSD + 1TB HDD")def build_graphics_card(self):self.computer.add("Integrated Graphics")# 导演类
class ComputerEngineer:def __init__(self):self.builder: ComputerBuilder = Nonedef set_builder(self, builder: ComputerBuilder):self.builder = builderdef build_computer(self):self.builder.build_cpu()self.builder.build_memory()self.builder.build_storage()self.builder.build_graphics_card()return self.builder.get_computer()def build_minimal_computer(self):"""构建简化版电脑"""self.builder.build_cpu()self.builder.build_memory()return self.builder.get_computer()# 使用
if __name__ == "__main__":engineer = ComputerEngineer()# 构建游戏电脑gaming_builder = GamingComputerBuilder()engineer.set_builder(gaming_builder)gaming_computer = engineer.build_computer()print("=== 游戏电脑 ===")print(gaming_computer)# 构建办公电脑office_builder = OfficeComputerBuilder()engineer.set_builder(office_builder)office_computer = engineer.build_computer()print("\n=== 办公电脑 ===")print(office_computer)# 构建简化版办公电脑minimal_office_computer = engineer.build_minimal_computer()print("\n=== 简化版办公电脑 ===")print(minimal_office_computer)

C++实现

#include <iostream>
#include <memory>
#include <vector>
#include <string>// 产品类
class Computer {
private:std::vector<std::string> parts;public:void addPart(const std::string& part) {parts.push_back(part);}void listParts() const {std::cout << "计算机配置: ";for (size_t i = 0; i < parts.size(); ++i) {std::cout << parts[i];if (i != parts.size() - 1) {std::cout << ", ";}}std::cout << std::endl;}
};// 抽象建造者
class ComputerBuilder {
protected:std::unique_ptr<Computer> computer;public:ComputerBuilder() : computer(std::make_unique<Computer>()) {}virtual ~ComputerBuilder() = default;virtual void buildCPU() = 0;virtual void buildMemory() = 0;virtual void buildStorage() = 0;virtual void buildGraphicsCard() = 0;std::unique_ptr<Computer> getComputer() {auto result = std::move(computer);computer = std::make_unique<Computer>();  // 重置用于下次构建return result;}
};// 具体建造者 - 游戏电脑
class GamingComputerBuilder : public ComputerBuilder {
public:void buildCPU() override {computer->addPart("Intel i9-13900K CPU");}void buildMemory() override {computer->addPart("32GB DDR5 RAM");}void buildStorage() override {computer->addPart("2TB NVMe SSD");}void buildGraphicsCard() override {computer->addPart("NVIDIA RTX 4090");}
};// 具体建造者 - 办公电脑
class OfficeComputerBuilder : public ComputerBuilder {
public:void buildCPU() override {computer->addPart("Intel i5-12400 CPU");}void buildMemory() override {computer->addPart("16GB DDR4 RAM");}void buildStorage() override {computer->addPart("512GB SSD + 1TB HDD");}void buildGraphicsCard() override {computer->addPart("Integrated Graphics");}
};// 导演类
class ComputerEngineer {
private:ComputerBuilder* builder;public:void setBuilder(ComputerBuilder* newBuilder) {builder = newBuilder;}std::unique_ptr<Computer> buildComputer() {builder->buildCPU();builder->buildMemory();builder->buildStorage();builder->buildGraphicsCard();return builder->getComputer();}std::unique_ptr<Computer> buildMinimalComputer() {builder->buildCPU();builder->buildMemory();return builder->getComputer();}
};// 使用
int main() {ComputerEngineer engineer;// 构建游戏电脑GamingComputerBuilder gamingBuilder;engineer.setBuilder(&gamingBuilder);auto gamingComputer = engineer.buildComputer();std::cout << "=== 游戏电脑 ===" << std::endl;gamingComputer->listParts();// 构建办公电脑OfficeComputerBuilder officeBuilder;engineer.setBuilder(&officeBuilder);auto officeComputer = engineer.buildComputer();std::cout << "\n=== 办公电脑 ===" << std::endl;officeComputer->listParts();// 构建简化版办公电脑auto minimalOfficeComputer = engineer.buildMinimalComputer();std::cout << "\n=== 简化版办公电脑 ===" << std::endl;minimalOfficeComputer->listParts();return 0;
}

3. 原型模式 (Prototype)

组件框图

┌─────────────────┐         ┌──────────────────┐
│   Client        │         │   Prototype      │
├─────────────────┤         ├──────────────────┤
│                 │───────>│+clone()          │
│                 │         └──────────────────┘
└─────────────────┘                   △┌─────────┴─────────┐┌──────────┴──────────┐ ┌─────┴────────┐│ ConcretePrototype1  │ │ConcretePrototype2│├─────────────────────┤ ├────────────────┤│+clone()             │ │+clone()        ││-field               │ │-field          │└─────────────────────┘ └────────────────┘

详细描述

问题：
需要创建的对象成本较高（如数据库操作、网络请求），或者希望避免使用子类来扩展对象创建。

解决方案：
通过复制现有对象来创建新对象，而不是通过新建类实例。

效果：

  • 优点：避免重复初始化操作，动态添加或删除产品

  • 缺点：复杂对象的克隆可能较困难，需要深拷贝考虑

Python实现

import copy
from abc import ABC, abstractmethod
from typing import List, Dict# 原型接口
class Prototype(ABC):@abstractmethoddef clone(self):pass# 具体原型 - 简历
class Resume(Prototype):def __init__(self, name: str = ""):self.name = nameself.work_experience: List[str] = []self.skills: List[str] = []self.personal_info: Dict[str, str] = {}def set_personal_info(self, key: str, value: str):self.personal_info[key] = valuedef add_work_experience(self, experience: str):self.work_experience.append(experience)def add_skill(self, skill: str):self.skills.append(skill)def clone(self):"""深拷贝克隆方法"""return copy.deepcopy(self)def shallow_clone(self):"""浅拷贝克隆方法"""return copy.copy(self)def display(self):print(f"\n=== 简历: {self.name} ===")print("个人信息:")for key, value in self.personal_info.items():print(f"  {key}: {value}")print("工作经历:")for exp in self.work_experience:print(f"  - {exp}")print("技能:")for skill in self.skills:print(f"  - {skill}")# 具体原型 - 图形对象
class GraphicObject(Prototype):def __init__(self, color: str = "black", x: int = 0, y: int = 0):self.color = colorself.x = xself.y = yself.children: List[GraphicObject] = []def add_child(self, child: 'GraphicObject'):self.children.append(child)def clone(self):"""深拷贝克隆，包括所有子对象"""return copy.deepcopy(self)def __str__(self):return f"GraphicObject(color={self.color}, position=({self.x},{self.y}), children={len(self.children)})"# 原型管理器
class PrototypeManager:def __init__(self):self._prototypes: Dict[str, Prototype] = {}def register_prototype(self, name: str, prototype: Prototype):self._prototypes[name] = prototypedef unregister_prototype(self, name: str):if name in self._prototypes:del self._prototypes[name]def clone_prototype(self, name: str) -> Prototype:if name in self._prototypes:return self._prototypes[name].clone()raise ValueError(f"原型 '{name}' 未注册")# 使用
if __name__ == "__main__":# 创建原型简历original_resume = Resume("张三")original_resume.set_personal_info("age", "28")original_resume.set_personal_info("email", "zhang@email.com")original_resume.add_work_experience("ABC公司 - 软件工程师 (2020-2023)")original_resume.add_skill("Python")original_resume.add_skill("C++")print("=== 原始简历 ===")original_resume.display()# 克隆简历并修改cloned_resume = original_resume.clone()cloned_resume.name = "李四"cloned_resume.set_personal_info("email", "li@email.com")cloned_resume.add_work_experience("XYZ公司 - 高级工程师 (2023-至今)")cloned_resume.add_skill("Java")print("\n=== 克隆并修改后的简历 ===")cloned_resume.display()# 原型管理器使用print("\n=== 原型管理器示例 ===")manager = PrototypeManager()manager.register_prototype("standard_resume", original_resume)# 快速创建多个相似简历resume1 = manager.clone_prototype("standard_resume")resume1.name = "王五"resume1.display()# 图形对象克隆print("\n=== 图形对象克隆 ===")original_graphic = GraphicObject("red", 10, 20)child1 = GraphicObject("blue", 5, 5)child2 = GraphicObject("green", 15, 15)original_graphic.add_child(child1)original_graphic.add_child(child2)cloned_graphic = original_graphic.clone()cloned_graphic.color = "yellow"cloned_graphic.x = 30print(f"原始对象: {original_graphic}")print(f"克隆对象: {cloned_graphic}")

C++实现

#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include <unordered_map>// 原型接口
class Prototype {
public:virtual ~Prototype() = default;virtual std::unique_ptr<Prototype> clone() const = 0;virtual void display() const = 0;
};// 具体原型 - 简历
class Resume : public Prototype {
private:std::string name;std::vector<std::string> workExperience;std::vector<std::string> skills;std::unordered_map<std::string, std::string> personalInfo;public:Resume(const std::string& name = "") : name(name) {}void setPersonalInfo(const std::string& key, const std::string& value) {personalInfo[key] = value;}void addWorkExperience(const std::string& experience) {workExperience.push_back(experience);}void addSkill(const std::string& skill) {skills.push_back(skill);}std::unique_ptr<Prototype> clone() const override {return std::make_unique<Resume>(*this);  // 使用拷贝构造函数}void display() const override {std::cout << "\n=== 简历: " << name << " ===" << std::endl;std::cout << "个人信息:" << std::endl;for (const auto& [key, value] : personalInfo) {std::cout << "  " << key << ": " << value << std::endl;}std::cout << "工作经历:" << std::endl;for (const auto& exp : workExperience) {std::cout << "  - " << exp << std::endl;}std::cout << "技能:" << std::endl;for (const auto& skill : skills) {std::cout << "  - " << skill << std::endl;}}// 拷贝构造函数Resume(const Resume& other): name(other.name),workExperience(other.workExperience),skills(other.skills),personalInfo(other.personalInfo) {}
};// 原型管理器
class PrototypeManager {
private:std::unordered_map<std::string, std::unique_ptr<Prototype>> prototypes;public:void registerPrototype(const std::string& name, std::unique_ptr<Prototype> prototype) {prototypes[name] = std::move(prototype);}void unregisterPrototype(const std::string& name) {prototypes.erase(name);}std::unique_ptr<Prototype> clonePrototype(const std::string& name) {auto it = prototypes.find(name);if (it != prototypes.end()) {return it->second->clone();}throw std::runtime_error("原型 '" + name + "' 未注册");}
};// 使用
int main() {// 创建原型简历auto originalResume = std::make_unique<Resume>("张三");originalResume->setPersonalInfo("age", "28");originalResume->setPersonalInfo("email", "zhang@email.com");originalResume->addWorkExperience("ABC公司 - 软件工程师 (2020-2023)");originalResume->addSkill("Python");originalResume->addSkill("C++");std::cout << "=== 原始简历 ===" << std::endl;originalResume->display();// 克隆简历auto clonedResume = originalResume->clone();auto* resumePtr = dynamic_cast<Resume*>(clonedResume.get());if (resumePtr) {// 注意：这里需要修改接口以支持修改，为了示例简化std::cout << "\n=== 克隆的简历 ===" << std::endl;resumePtr->display();}// 原型管理器使用std::cout << "\n=== 原型管理器示例 ===" << std::endl;PrototypeManager manager;manager.registerPrototype("standard_resume", std::move(originalResume));// 快速创建多个相似简历auto resume1 = manager.clonePrototype("standard_resume");resume1->display();return 0;
}

4. 单例模式 (Singleton)

组件框图

┌─────────────────┐
│   Singleton     │
├─────────────────┤
│-instance        │
│-data            │
├─────────────────┤
│-Singleton()     │
│+getInstance()   │
│+businessLogic() │
└─────────────────┘

详细描述

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

解决方案：
将构造函数私有化，提供一个静态方法返回唯一实例。

效果：

  • 优点：严格控制实例数量，全局访问点

  • 缺点：可能隐藏过度耦合，难以测试，违反单一职责原则

Python实现

import threading
from typing import Dict, Anyclass SingletonMeta(type):"""单例元类，线程安全版本"""_instances: Dict[type, Any] = {}_lock: threading.Lock = threading.Lock()def __call__(cls, *args, **kwargs):with cls._lock:if cls not in cls._instances:instance = super().__call__(*args, **kwargs)cls._instances[cls] = instancereturn cls._instances[cls]# 数据库连接单例
class DatabaseConnection(metaclass=SingletonMeta):def __init__(self, connection_string: str = "default_connection"):self.connection_string = connection_stringself.is_connected = Falseself._connection_count = 0print(f"初始化数据库连接: {connection_string}")def connect(self):if not self.is_connected:self.is_connected = Trueself._connection_count += 1print("数据库连接已建立")else:print("数据库已经连接")def disconnect(self):if self.is_connected:self.is_connected = Falseprint("数据库连接已断开")else:print("数据库已经断开")def execute_query(self, query: str):if self.is_connected:print(f"执行查询: {query}")return f"查询结果: {query}"else:raise Exception("数据库未连接")def get_connection_count(self):return self._connection_count# 配置管理器单例
class ConfigurationManager(metaclass=SingletonMeta):def __init__(self):self._config = {"database": {"host": "localhost","port": 5432,"username": "admin"},"application": {"name": "MyApp","version": "1.0.0"}}print("配置管理器初始化完成")def get(self, key: str, default=None):"""获取配置项"""keys = key.split('.')value = self._configtry:for k in keys:value = value[k]return valueexcept (KeyError, TypeError):return defaultdef set(self, key: str, value):"""设置配置项"""keys = key.split('.')config = self._configfor k in keys[:-1]:if k not in config:config[k] = {}config = config[k]config[keys[-1]] = valuedef show_config(self):"""显示所有配置"""import jsonprint("当前配置:")print(json.dumps(self._config, indent=2, ensure_ascii=False))# 线程测试
def test_singleton_thread(thread_id: int):"""测试多线程环境下的单例"""db = DatabaseConnection()db.connect()config = ConfigurationManager()app_name = config.get("application.name")print(f"线程 {thread_id} - 应用名称: {app_name}")# 使用
if __name__ == "__main__":print("=== 单例模式演示 ===")# 测试数据库连接单例print("\n1. 数据库连接单例测试:")db1 = DatabaseConnection("postgresql://localhost:5432/mydb")db2 = DatabaseConnection("different_connection")  # 这个不会生效db1.connect()db2.connect()  # 实际上是同一个实例print(f"db1 is db2: {db1 is db2}")print(f"连接次数: {db1.get_connection_count()}")# 测试配置管理器单例print("\n2. 配置管理器单例测试:")config1 = ConfigurationManager()config2 = ConfigurationManager()print(f"config1 is config2: {config1 is config2}")# 获取配置db_host = config1.get("database.host")app_version = config1.get("application.version")print(f"数据库主机: {db_host}")print(f"应用版本: {app_version}")# 修改配置config1.set("database.port", 3306)config1.show_config()# 多线程测试print("\n3. 多线程单例测试:")threads = []for i in range(3):thread = threading.Thread(target=test_singleton_thread, args=(i,))threads.append(thread)thread.start()for thread in threads:thread.join()

C++实现

#include <iostream>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>// 数据库连接单例
class DatabaseConnection {
private:static std::unique_ptr<DatabaseConnection> instance;static std::mutex mutex;std::string connectionString;bool isConnected;int connectionCount;// 私有构造函数DatabaseConnection(const std::string& connStr = "default_connection") : connectionString(connStr), isConnected(false), connectionCount(0) {std::cout << "初始化数据库连接: " << connectionString << std::endl;}public:// 删除拷贝构造函数和赋值操作符DatabaseConnection(const DatabaseConnection&) = delete;DatabaseConnection& operator=(const DatabaseConnection&) = delete;// 获取单例实例static DatabaseConnection& getInstance(const std::string& connStr = "default_connection") {std::lock_guard<std::mutex> lock(mutex);if (!instance) {instance = std::unique_ptr<DatabaseConnection>(new DatabaseConnection(connStr));}return *instance;}void connect() {if (!isConnected) {isConnected = true;connectionCount++;std::cout << "数据库连接已建立" << std::endl;} else {std::cout << "数据库已经连接" << std::endl;}}void disconnect() {if (isConnected) {isConnected = false;std::cout << "数据库连接已断开" << std::endl;} else {std::cout << "数据库已经断开" << std::endl;}}void executeQuery(const std::string& query) {if (isConnected) {std::cout << "执行查询: " << query << std::endl;} else {throw std::runtime_error("数据库未连接");}}int getConnectionCount() const {return connectionCount;}std::string getConnectionString() const {return connectionString;}
};// 静态成员初始化
std::unique_ptr<DatabaseConnection> DatabaseConnection::instance = nullptr;
std::mutex DatabaseConnection::mutex;// 配置管理器单例
class ConfigurationManager {
private:static ConfigurationManager* instance;static std::mutex mutex;std::unordered_map<std::string, std::string> config;ConfigurationManager() {// 默认配置config["database.host"] = "localhost";config["database.port"] = "5432";config["application.name"] = "MyApp";config["application.version"] = "1.0.0";std::cout << "配置管理器初始化完成" << std::endl;}public:ConfigurationManager(const ConfigurationManager&) = delete;ConfigurationManager& operator=(const ConfigurationManager&) = delete;static ConfigurationManager& getInstance() {std::lock_guard<std::mutex> lock(mutex);if (!instance) {instance = new ConfigurationManager();}return *instance;}static void destroyInstance() {std::lock_guard<std::mutex> lock(mutex);delete instance;instance = nullptr;}std::string get(const std::string& key, const std::string& defaultValue = "") {auto it = config.find(key);if (it != config.end()) {return it->second;}return defaultValue;}void set(const std::string& key, const std::string& value) {config[key] = value;}void showConfig() {std::cout << "当前配置:" << std::endl;for (const auto& [key, value] : config) {std::cout << "  " << key << ": " << value << std::endl;}}
};// 静态成员初始化
ConfigurationManager* ConfigurationManager::instance = nullptr;
std::mutex ConfigurationManager::mutex;// 使用
int main() {std::cout << "=== 单例模式演示 ===" << std::endl;// 测试数据库连接单例std::cout << "\n1. 数据库连接单例测试:" << std::endl;DatabaseConnection& db1 = DatabaseConnection::getInstance("postgresql://localhost:5432/mydb");DatabaseConnection& db2 = DatabaseConnection::getInstance("different_connection");db1.connect();db2.connect();  // 实际上是同一个实例std::cout << "db1 和 db2 是同一个实例: " << (&db1 == &db2) << std::endl;std::cout << "连接次数: " << db1.getConnectionCount() << std::endl;std::cout << "连接字符串: " << db1.getConnectionString() << std::endl;// 测试配置管理器单例std::cout << "\n2. 配置管理器单例测试:" << std::endl;ConfigurationManager& config1 = ConfigurationManager::getInstance();ConfigurationManager& config2 = ConfigurationManager::getInstance();std::cout << "config1 和 config2 是同一个实例: " << (&config1 == &config2) << std::endl;// 获取和修改配置std::string dbHost = config1.get("database.host");std::string appVersion = config1.get("application.version");std::cout << "数据库主机: " << dbHost << std::endl;std::cout << "应用版本: " << appVersion << std::endl;config1.set("database.port", "3306");config1.showConfig();// 清理ConfigurationManager::destroyInstance();return 0;
}

模式对比总结

模式主要目的适用场景关键特性
抽象工厂创建产品族需要系列相关产品工厂接口，产品兼容性
建造者复杂对象构建构建过程复杂，步骤多分步构建，相同过程不同表示
原型对象克隆创建成本高，避免子类克隆方法，深拷贝/浅拷贝
单例唯一实例需要全局访问点，控制实例数量私有构造，静态实例，线程安全

这些创建型模式都解决了对象创建的不同方面问题，在实际开发中可以根据具体需求选择合适的模式。

http://www.dtcms.com/a/426644.html

相关文章：

  • 即墨网站建设公司旅游网站建设电子商务的困惑
  • 央视优购物官方网站网页制作与网站管理
  • 本地多版本 Node.js 切换指南：解决 Vue nodejs 等项目版本冲突问题
  • 阿里云 AI 中间件重磅发布，打通 AI 应用落地“最后一公里”
  • 全面解析Umi-OCR手写体识别能力：开源OCR的新标杆
  • Spring Boot整合Kafka：解决消息挤压、丢失与重复消费
  • 【系统架构师-案例分析】2025年5月份案例分析第一题-架构评估
  • OpenHarmony之Histreamer引擎深度解析：pipeline_core架构如何全面取代GStreamer，一统音视频播放与录制
  • 个人简历html代码山西seo推广方案
  • ARM芯片架构之coresight 时间戳组件介绍
  • LeetCode算法日记 - Day 58: 目标和、数组总和
  • 在不同开发语言与场景下设计模式的使用
  • 服务机构电子商务网站有哪些软件外包公司开发流程
  • 微软 2025 年 8 月更新：对固态硬盘与电脑功能有哪些潜在的影响
  • VB6 ADO没有轻量级内存数据库吗？类似SQLITE
  • 微软Windows原罪不可原谅
  • 微软警示AI驱动的钓鱼攻击：LLM生成的SVG文件绕过邮件安全检测
  • 使用Java将Excel转换为Text
  • 智源 RoboBrain-X0 开源，打破机器人跨本体泛化困境
  • ITK-基于欧拉变换与质心对齐的二维刚性配准算法
  • 2025-2031年全球箱体与盒体搬运机器人行业全景报告（含市场规模、竞争格局及投资潜力）
  • 苍穹外卖项目面试总结话术
  • 【3D图像技术讨论】3A游戏场景重建实战指南：从数据采集到实时渲染的开源方案
  • Kanass入门到实战(6) - 如何进行缺陷管理
  • 湛江建网站网页界面设计内容
  • 打印设备T型非晶磁环——高频抗干扰的核心元件｜深圳维爱普
  • pg_resetwal 使用简介
  • Spring Boot 集成 Redis 缓存解决方案
  • 微服务核心组件解析：注册中心与负载均衡（Eureka/Nacos/Ribbon）
  • GNS3环境下静态路由配置实例与分析（管理距离、度量值）