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

Abstract Factory(抽象工厂模式)

news 2025/6/17 18:00:27

1. 意图

        旨在提供对象创建管理接口，对一系列相关或相互依赖的对象提供统一创建接口，避免在软件中使用各类创建其对象。

2. 适用性

        《Gof 设计模式-可复用面向对象软件的基础》中对此模式的适用性描述如下：

  • 一个系统要独立于它的产品的创建、组合和表示时。
  • 一个系统要由多个系列产品中的一个来配置时。
  • 要强调一系列相关的产品对象的设计以便进行联合使用时。
  • 提供一个产品类库，而只想显示他们的接口而不是实现时。

3. 实现

  • 简单工厂模式：实现相对简单，类成员函数可以根据不同的参数创建不同的对象，被创建的类对象一般都拥有相同的基类。
class Computer {
public:virtual ~Computer (){}virtual void Print() = 0;
};class Memory : public Computer {virtual void Print() override { std::cout << "Memory" << std::endl; }
};
class Cpu : public Computer {virtual void Print() override { std::cout << "Cpu" << std::endl; }
};
class Screen : public Computer {virtual void Print() override { std::cout << "Screen" << std::endl; }
};class SimpleFactory {
public:enum class EnumCreateType { kMemory, kCpu, kScreen };Computer *Create(const EnumCreateType &type) {switch (type) {case EnumCreateType::kMemory:return new Memory;break;case EnumCreateType::kCpu:return new Cpu;break;case EnumCreateType::kScreen:return new Screen;break;default:;}return nullptr;}
};void Test() {SimpleFactory factor;Computer *ptr = factor.Create(SimpleFactory::EnumCreateType::kMemory);if (ptr) {ptr->Print();delete ptr;}ptr = factor.Create(SimpleFactory::EnumCreateType::kCpu);if (ptr) {ptr->Print();delete ptr;}ptr = factor.Create(SimpleFactory::EnumCreateType::kScreen);if (ptr) {ptr->Print();delete ptr;}
}int main() {Test();return 0;
}

执行输出

Memory
Cpu
Screen

简单工厂模式模板实现

class Computer {
public:virtual ~Computer (){}virtual void Print() = 0;
};class Memory : public Computer {
public:Memory(int id) : Computer(), m_id(id) {}virtual void Print() override { std::cout << "Memory " << m_id << std::endl; }private:int m_id;
};
class Cpu : public Computer {
public:Cpu(int id) : Computer(), m_id(id) {}virtual void Print() override { std::cout << "Cpu " << m_id << std::endl; }private:int m_id;
};
class Screen : public Computer {
public:Screen(int id) : Computer(), m_id(id) {}virtual void Print() override { std::cout << "Screen " << m_id << std::endl; }private:int m_id;
};class SimpleFactory {
public:enum class EnumCreateType { kMemory, kCpu, kScreen };template <typename... Args>Computer *Create(const EnumCreateType &type, Args &&...args) {switch (type) {case EnumCreateType::kMemory:return new Memory(std::forward<Args>(args)...);break;case EnumCreateType::kCpu:return new Cpu(std::forward<Args>(args)...);break;case EnumCreateType::kScreen:return new Screen(std::forward<Args>(args)...);break;default:;}return nullptr;}
};void Test() {SimpleFactory factor;Computer *ptr = factor.Create(SimpleFactory::EnumCreateType::kMemory, 10);if (ptr) {ptr->Print();delete ptr;}ptr = factor.Create(SimpleFactory::EnumCreateType::kCpu, 20);if (ptr) {ptr->Print();delete ptr;}ptr = factor.Create(SimpleFactory::EnumCreateType::kScreen, 30);if (ptr) {ptr->Print();delete ptr;}
}int main() {Test();return 0;
}

执行输出

Memory 10
Cpu 20
Screen 30
  • 工厂方法模式：使用多个工厂类来创建多种类对象。
class Computer {
public:virtual ~Computer() {}virtual void Print() = 0;
};class Memory : public Computer {virtual void Print() override { std::cout << "Memory" << std::endl; }
};
class Cpu : public Computer {virtual void Print() override { std::cout << "Cpu" << std::endl; }
};
class Screen : public Computer {virtual void Print() override { std::cout << "Screen" << std::endl; }
};class FactoryMethod {
public:virtual ~FactoryMethod() {}virtual Computer *Create() = 0;
};class MemoryFactory : public FactoryMethod {
public:virtual Computer *Create() override { return new Memory; }
};class CpuFactory : public FactoryMethod {
public:virtual Computer *Create() override { return new Cpu; }
};class ScreenFactory : public FactoryMethod {
public:virtual Computer *Create() override { return new Screen; }
};void Test() {try {FactoryMethod *factor = new MemoryFactory;Computer *ptr = factor->Create();if (ptr) {ptr->Print();delete ptr;delete factor;}factor = new CpuFactory;ptr = factor->Create();if (ptr) {ptr->Print();delete ptr;delete factor;}factor = new ScreenFactory;ptr = factor->Create();if (ptr) {ptr->Print();delete ptr;delete factor;}} catch (const std::bad_alloc &err) {std::cout << err.what() << std::endl;}
}int main() {Test();return 0;
}

执行输出

Memory
Cpu
Screen
  • 抽象工厂模式：一个工厂子类不止能创建一种具有相同规则的对象，相对于工厂模式就可以有效的减少创建工厂子类的数量。
#include <iostream>class Memory {
public:virtual ~Memory() {}virtual void Print() = 0;
};
class CMemory : public Memory {
public:virtual void Print() override { std::cout << "CMemory" << std::endl; }
};
class RMemory : public Memory {
public:virtual void Print() override { std::cout << "RMemory" << std::endl; }
};
class FMemory : public Memory {
public:virtual void Print() override { std::cout << "FMemory" << std::endl; }
};class Cpu {
public:virtual ~Cpu() {}virtual void Print() = 0;
};
class CCpu : public Cpu {
public:virtual void Print() override { std::cout << "CCpu" << std::endl; }
};
class RCpu : public Cpu {
public:virtual void Print() override { std::cout << "RCpu" << std::endl; }
};
class FCpu : public Cpu {
public:virtual void Print() override { std::cout << "FCpu" << std::endl; }
};class Screen {
public:virtual ~Screen() {}virtual void Print() = 0;
};
class CScreen : public Screen {
public:virtual void Print() override { std::cout << "CScreen" << std::endl; }
};
class RScreen : public Screen {
public:virtual void Print() override { std::cout << "RScreen" << std::endl; }
};
class FScreen : public Screen {
public:virtual void Print() override { std::cout << "FScreen" << std::endl; }
};class AbstractFactory {
public:virtual ~AbstractFactory() {}virtual Memory *CreateMemory() = 0;virtual Cpu *CreateCpu() = 0;virtual Screen *CreateScreen() = 0;
};class CFactory : public AbstractFactory {
public:virtual Memory *CreateMemory() override { return new CMemory; }virtual Cpu *CreateCpu() override { return new CCpu; }virtual Screen *CreateScreen() override { return new CScreen; }
};class RFactory : public AbstractFactory {
public:virtual Memory *CreateMemory() override { return new RMemory; }virtual Cpu *CreateCpu() override { return new RCpu; }virtual Screen *CreateScreen() override { return new RScreen; }
};class FFactory : public AbstractFactory {
public:virtual Memory *CreateMemory() override { return new FMemory; }virtual Cpu *CreateCpu() override { return new FCpu; }virtual Screen *CreateScreen() override { return new FScreen; }
};class Computer {
public:void Assemble(Memory *memory, Cpu *cpu, Screen *screen) {memory->Print();cpu->Print();screen->Print();}
};void Test() {AbstractFactory *factor1 = new CFactory;Memory *m1 = factor1->CreateMemory();Cpu *c1 = factor1->CreateCpu();Screen *s1 = factor1->CreateScreen();AbstractFactory *factor2 = new RFactory;Memory *m2 = factor2->CreateMemory();Cpu *c2 = factor2->CreateCpu();Screen *s2 = factor2->CreateScreen();AbstractFactory *factor3 = new FFactory;Memory *m3 = factor3->CreateMemory();Cpu *c3 = factor3->CreateCpu();Screen *s3 = factor3->CreateScreen();Computer computer;computer.Assemble(m1, c2, s3);computer.Assemble(m2, c3, s2);computer.Assemble(m3, c1, s1);delete factor1;delete factor2;delete factor3;delete m1;delete m2;delete m3;delete c1;delete c2;delete c3;delete s1;delete s2;delete s3;
}int main() {Test();return 0;
}

执行输出

CMemory    RCpu    FScreen
RMemory    FCpu    RScreen
FMemory    CCpu    CScreen

4. 优缺点

  • 它分离了具体的类
  • 有利于产品的一致性
  • 难以支持新种类的产品

http://www.mrgr.cn/news/43638.html

相关文章：

  • 多模态理论基础——什么是多模态？
  • VSCode debug模式无法跳转进入内置模块
  • STM32中断编程指南：NVIC和中断优先级
  • unity ps 2d animation 蛇的制作
  • VUE2常见问题以及解决方案汇总（不断更新中）
  • 查缺补漏----同步，异步，半同步，分离式通信
  • 服务器conda环境安装rpy2
  • 【Codeforces】CF 2007 E
  • RTR_Chapter_6 下
  • C语言 | Leetcode C语言题解之第458题可怜的小猪
  • 【WPF开发】如何设置窗口背景颜色以及背景图片
  • 深入理解CSS弹性盒子模型（Flexbox）
  • 深度学习中的结构化概率模型 - 结构化概率模型的深度学习方法篇
  • 【WPF开发】样式表基础及入门
  • 如何写好计算机毕业设计论文？【大纲+技巧+示例】
  • Python | Leetcode Python题解之第458题可怜的小猪
  • Emissive CEO Fabien Barati谈《消失的法老》背后的故事：XR大空间体验的创新与未来
  • Android 14.0 Launcher3 app图标和hotseat 添加背景(焦点选中背景)
  • STM32入门-GPIO端口的八种工作模式
  • QGIS中怎么加载数据（如矢量shp与栅格数据）