C++学习笔记(二十九)简单工厂、工厂方法、抽象工厂之小结、区别

简单工厂、工厂方法、抽象工厂之小结、区别

  很多时候,我发现这三种设计模式难以区分,常常会张冠李戴闹了笑话。很有必要深入总结一下三种设计模式的特点、相同之处和不同之处。

1 本质

  三个设计模式名字中都含有“工厂”二字,其含义是使用工厂(一个或一系列方法)去生产产品(一个或一系列类的实例)

  另外,有时候,我们常常会将生产产品的一个或一系列方法封装到一个类中,我习惯把这个类叫做“工厂类”;而被实例化的类称作“产品类”。

2 简单工厂

  工厂类(SimpleFactory)拥有一个工厂方法(create),接受了一个参数,通过不同的参数实例化不同的产品类。

  如下边UML类图所示为简单工厂。  

  

  优点:

    (1)很明显,简单工厂的特点就是“简单粗暴”,通过一个含参的工厂方法,我们可以实例化任何产品类,上至飞机火箭,下至土豆面条,无所不能。所以简单工厂有一个别名:上帝类。

  缺点:

    (1)任何”东西“的子类都可以被生产,负担太重。当所要生产产品种类非常多时,工厂方法的代码量可能会很庞大。

    (2)在遵循开闭原则(对拓展开放,对修改关闭)的条件下,简单工厂对于增加新的产品,无能为力。因为增加新产品只能通过修改工厂方法来实现。

  工厂方法正好可以解决简单工厂的这两个缺点。

3 工厂方法

  工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。

  如下边UML类图所示为工厂方法。

  

  优点:

    (1)工厂方法模式就很好的减轻了工厂类的负担,把某一类/某一种东西交由一个工厂生产;(对应简单工厂的缺点1)

    (2)同时增加某一类”东西“并不需要修改工厂类,只需要添加生产这类”东西“的工厂即可,使得工厂类符合开放-封闭原则。

  缺点:

    (1)相比简单工厂,实现略复杂。

    (2)对于某些可以形成产品族的情况处理比较复杂。

  对于缺点(2),我们可以借用抽象工厂来实现。

4 抽象工厂

  抽象工厂是应对产品族概念的。

  例如,汽车可以分为轿车、SUV、MPV等,也分为奔驰、宝马等。我们可以将奔驰的所有车看作是一个产品族,而将宝马的所有车看作是另一个产品族。分别对应两个工厂,一个是奔驰的工厂,另一个是宝马的工厂。与工厂方法不同,奔驰的工厂不只是生产具体的某一个产品,而是一族产品(奔驰轿车、奔驰SUV、奔驰MPV)。“抽象工厂”的“抽象”指的是就是这个意思。

  上边的工厂方法模式是一种极端情况的抽象工厂模式(即只生产一种产品的抽象工厂模式),而抽象工厂模式可以看成是工厂方法模式的一种推广。

  如下边UML类图所示为抽象工厂。

  

  优点:针对产品族;

  缺点:针对产品族。

  所以,只有对应产品族的情况下,才需要使用抽象工厂模式。

5 区别

  简单工厂 : 用来生产同一等级结构中的任意产品。(不支持拓展增加产品)

  工厂方法 :用来生产同一等级结构中的固定产品。(支持拓展增加产品)   

  抽象工厂 :用来生产不同产品族的全部产品。(不支持拓展增加产品;支持增加产品族)  

6 注意事项

  (1)工厂类常常采用单例模式(Singleton)。

  (2)工厂类拥有基类(定义共同接口),基类可以为纯虚类,也可以定义缺省方法。

  (3)对于工厂方法和抽象工厂,基类中的生产产品的函数常常为虚函数,以实现动态绑定。

  (4)调用工厂方法的函数通常采用工厂实现的指针和引用作为形参,以便根据不同的工厂实参调用不同的工厂方法。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
抽象工厂方法模式(Abstract Factory Pattern)是一种创建型设计模式,它提供了一个接口,用于创建一系列相关或依赖对象的家族,而无需指定它们具体的类。 在 C++ 中,抽象工厂方法模式通常通过定义一个抽象基类来实现。这个抽象基类定义了一系列纯虚函数,用于创建不同类型的产品对象。然后,针对不同的产品族,创建具体的工厂类,这些工厂类实现了抽象基类中定义的纯虚函数,用于创建具体的产品对象。 以下是一个简单的抽象工厂方法模式的示例代码: ```c++ // 抽象产品类 A class AbstractProductA { public: virtual void operationA() = 0; }; // 抽象产品类 B class AbstractProductB { public: virtual void operationB() = 0; }; // 具体产品类 A1 class ConcreteProductA1 : public AbstractProductA { public: void operationA() { std::cout << "ConcreteProductA1::operationA()" << std::endl; } }; // 具体产品类 A2 class ConcreteProductA2 : public AbstractProductA { public: void operationA() { std::cout << "ConcreteProductA2::operationA()" << std::endl; } }; // 具体产品类 B1 class ConcreteProductB1 : public AbstractProductB { public: void operationB() { std::cout << "ConcreteProductB1::operationB()" << std::endl; } }; // 具体产品类 B2 class ConcreteProductB2 : public AbstractProductB { public: void operationB() { std::cout << "ConcreteProductB2::operationB()" << std::endl; } }; // 抽象工厂类 class AbstractFactory { public: virtual AbstractProductA* createProductA() = 0; virtual AbstractProductB* createProductB() = 0; }; // 具体工厂类 1 class ConcreteFactory1 : public AbstractFactory { public: AbstractProductA* createProductA() { return new ConcreteProductA1(); } AbstractProductB* createProductB() { return new ConcreteProductB1(); } }; // 具体工厂类 2 class ConcreteFactory2 : public AbstractFactory { public: AbstractProductA* createProductA() { return new ConcreteProductA2(); } AbstractProductB* createProductB() { return new ConcreteProductB2(); } }; int main() { AbstractFactory* factory1 = new ConcreteFactory1(); AbstractProductA* productA1 = factory1->createProductA(); AbstractProductB* productB1 = factory1->createProductB(); productA1->operationA(); // 输出:ConcreteProductA1::operationA() productB1->operationB(); // 输出:ConcreteProductB1::operationB() AbstractFactory* factory2 = new ConcreteFactory2(); AbstractProductA* productA2 = factory2->createProductA(); AbstractProductB* productB2 = factory2->createProductB(); productA2->operationA(); // 输出:ConcreteProductA2::operationA() productB2->operationB(); // 输出:ConcreteProductB2::operationB() return 0; } ``` 在上面的示例代码中,我们定义了两个抽象产品类 `AbstractProductA` 和 `AbstractProductB`,以及四个具体产品类 `ConcreteProductA1`、`ConcreteProductA2`、`ConcreteProductB1` 和 `ConcreteProductB2`。然后,我们定义了一个抽象工厂类 `AbstractFactory`,它包含两个纯虚函数,用于创建不同类型的产品对象。最后,我们定义了两个具体工厂类 `ConcreteFactory1` 和 `ConcreteFactory2`,它们分别实现了 `AbstractFactory` 中定义的纯虚函数,用于创建具体的产品对象。 在 `main` 函数中,我们首先创建了一个 `ConcreteFactory1` 对象,然后使用它创建了一个 `ConcreteProductA1` 和一个 `ConcreteProductB1` 对象,并调用了它们的成员函数。然后,我们创建了一个 `ConcreteFactory2` 对象,使用它创建了一个 `ConcreteProductA2` 和一个 `ConcreteProductB2` 对象,并调用了它们的成员函数。 通过这种方式,我们可以轻松地创建一系列相关或依赖对象的家族,并且无需指定它们具体的类。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值