Headfirst设计模式的C++实现——抽象工厂(Abstract Factory)

Dough.h

1 #ifndef _DOUGH_H
2 #define _DOUGH_H
3
4 class Dough
5 {
6 };
7 #endif

ThinCrustDough.h

1 #ifndef _THIN_CRUST_DOUGH_H
2 #define _THIN_CRUST_DOUGH_H
3
4 #include "Dough.h"
5
6 class ThinCrustDough : public Dough
7 {
8 };
9 #endif

Sauce.h

1 #ifndef _SAUCE_H
2 #define _SAUCE_H
3
4 class Sauce
5 {
6 };
7 #endif

MarinaraSauce.h

1 #ifndef _MARINARA_SAUCE_H
2 #define _MARINARA_SAUCE_H
3
4 #include "Sauce.h"
5
6 class MarinaraSauce : public Sauce
7 {
8 };
9 #endif

Pizza.h

 1 #ifndef _PIZZA_H
 2 #define _PIZZA_H
 3 #include <iostream>
 4 #include <string>
 5 #include "Dough.h"
 6 #include "Sauce.h"
 7 class Pizza
 8 {
 9 public:
10     Pizza() : m_name(), m_p_dough(NULL), m_p_sauce(NULL) {}
11     virtual ~Pizza() {}
12     virtual void prepare() = 0;
13     virtual void bake() { std::cout << "Bake for 25 mins at 350" << std::endl; }
14     virtual void cut() { std::cout << "Cutting the pizza into diagonal slices" << std::endl; }
15     virtual void box() { std::cout << "Place pizza in official PizzaStore box" << std::endl; }
16     void set_name(const std::string &name) { m_name = name; }
17     std::string get_name() { return m_name; }
18     Dough *m_p_dough;
19     Sauce *m_p_sauce;
20 private:
21     std::string m_name;
22 };
23 #endif

CheesePizza.h

 1 #ifndef _CHEESE_PIZZA_H
 2 #define _CHEESE_PIZZA_H
 3
 4 #include "Pizza.h"
 5 #include "PizzaIngredientFactory.h"
 6
 7 class CheesePizza : public Pizza
 8 {
 9 private:
10     PizzaIngredientFactory *m_p_ingredient_factory;
11 public:
12     CheesePizza(PizzaIngredientFactory *p) : m_p_ingredient_factory(p) {}
13     void prepare()
14     {
15         std::cout << "Preparing " << get_name() << std::endl;
16         m_p_sauce = m_p_ingredient_factory->create_sauce();
17     }
18 };
19
20 #endif

GreekPizza.h

 1 #ifndef _GREEK_PIZZA_H
 2 #define _GREEK_PIZZA_H
 3
 4 #include "Pizza.h"
 5 #include "PizzaIngredientFactory.h"
 6
 7 class GreekPizza : public Pizza
 8 {
 9 private:
10     PizzaIngredientFactory *m_p_ingredient_factory;
11 public:
12     GreekPizza(PizzaIngredientFactory *p) : m_p_ingredient_factory(p) {}
13     void prepare()
14     {
15         std::cout << "Preparing " << get_name() << std::endl;
16         m_p_dough = m_p_ingredient_factory->create_dough();
17     }
18 };
19
20 #endif

PizzaStore.h

 1 #ifndef _PIZZA_STORE_H
 2 #define _PIZZA_STORE_H
 3
 4 #include "Pizza.h"
 5
 6 class PizzaStore
 7 {
 8 private:
 9     virtual Pizza* CreatePizza(const std::string &type) = 0;
10 public:
11     Pizza* OrderPizza(const std::string &type)
12     {
13         Pizza *p_pizza = CreatePizza(type);
14         if (p_pizza)
15         {
16             p_pizza->prepare();
17             p_pizza->bake();
18             p_pizza->cut();
19             p_pizza->box();
20         }
21         return p_pizza;
22     }
23 };
24 #endif

NYPizzaStore.h

 1 #ifndef _NY_PIZZA_STORE_H
 2 #define _NY_PIZZA_STORE_H
 3
 4 #include "PizzaStore.h"
 5 #include "CheesePizza.h"
 6 #include "GreekPizza.h"
 7 #include "NYPizzaIngredientFactory.h"
 8 class NYPizzaStore : public PizzaStore
 9 {
10 private:
11     Pizza* CreatePizza(const std::string &type)
12     {
13         PizzaIngredientFactory *p_factory = new NYPizzaIngredientFactory();
14         if ( "cheese" == type )
15         {
16             Pizza *p_pizza = new CheesePizza( p_factory );
17             p_pizza->set_name("New York Style Cheese Pizza");
18             return p_pizza;
19         }
20         if ( "greek" == type )
21         {
22             Pizza *p_pizza = new GreekPizza( p_factory );
23             p_pizza->set_name("New York Style Greek Pizza");
24             return p_pizza;
25         }
26         return NULL;
27     }
28 };
29 #endif

PizzaIngredientFactory.h

 1 #ifndef _PIZZA_INGREDIENT_FACTORY_H
 2 #define _PIZZA_INGREDIENT_FACTORY_H
 3
 4 #include "Dough.h"
 5 #include "Sauce.h"
 6
 7 class PizzaIngredientFactory
 8 {
 9 public:
10     virtual Dough* create_dough() = 0;
11     virtual Sauce* create_sauce() = 0;
12 };
13
14 #endif

NYPizzaIngredientFactory.h

 1 #ifndef _NY_PIZZA_INGREDIENT_FACTORY_H
 2 #define _NY_PIZZA_INGREDIENT_FACTORY_H
 3
 4 #include "ThinCrustDough.h"
 5 #include "MarinaraSauce.h"
 6
 7 class NYPizzaIngredientFactory : public PizzaIngredientFactory
 8 {
 9 public:
10     Dough* create_dough() { std::cout << "Creating Thin Crust Dough" << std::endl; return new ThinCrustDough(); }
11     Sauce* create_sauce() { std::cout << "Creating Marinara Sauce" << std::endl; return new MarinaraSauce(); }
12 };
13
14 #endif

main.cpp

 1 #include "NYPizzaStore.h"
 2 int main()
 3 {
 4     NYPizzaStore pizza_store;
 5     Pizza *p_pizza = pizza_store.OrderPizza("greek");
 6     if ( p_pizza )
 7     {
 8         delete p_pizza;
 9     }
10     return 0;
11 }
时间: 2024-11-05 19:35:58

Headfirst设计模式的C++实现——抽象工厂(Abstract Factory)的相关文章

设计模式(一) 抽象工厂(Abstract Factory)

1.定义 抽象工厂是一种常用的对象创建型设计模式.抽象工厂模式提供了一种方式,可以将一组具有统一主题的单独工厂封装起来,它提供一个创建一系列相关或相互依赖对象的接口,而无需制定它们具体的类. 2.结构 抽象工厂的结构图如下所示: AbstractFactory : 声明一个创建抽象产品对象的操作接口 ConcreteFactory : 实现创建具体产品对象的操作 AbstractProduct : 为一个类产品对象声明一个接口 ConcreteProduct : 定义一个将被相应的具体工厂创建产

【设计模式】创建型模式之抽象工厂Abstract Factory

抽象工厂Abstract Factory是一种创建型设计模式,目的在于提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类.抽象工厂的类图如下,客户仅与抽象类定义的定义的接口交互,而不使用特定的具体类的接口.一个系统包含多种产品时,AbstractFactory声明创建各种抽象产品对象的操作接口,这些接口是直接暴露给Client的,而具体产品对象的创建则延迟到子类ConcreteFactory,Client面对的产品类是AbstractProduct,无需关系具体产品类是什么.在运

【设计模式】——抽象工厂Abstract Factory

模式意图 提供对象的使用接口,隐藏对象的创建过程. 模式结构 AbstractFactory 提供创建对象的接口. ConcreteFactory 提供真正创建对象的实现类,用于组合并创建不同的对象,实现一个产品族. AbstractProduct 提供对象的使用接口. ConcreteProduct 提供真正的适用对象,隐藏该对象的创建过程,是工厂创建的对象. Client 使用者,通过抽象工厂接口,使用不同的具体工厂方法创建对象组合,从而直接使用对象,无需关注对象的创建过程. 适合场景 1

面向对象设计——抽象工厂(Abstract Factory)模式

定义 提供一个创建一系列相关或者相互依赖对象的接口,而无需指定它们具体的类.抽象工厂允许客户使用抽象的接口来创建一组相关的产品,而不需要知道或关心实际产出的具体产品是什么.这样一来,客户就能从具体的产品中被解耦. 适用场景 在以下情况可以使用Abstract Factory模式 一个系统要独立于它的产品的创建.组合和表示时 一个系统要由多个产品系列中的一个来配置时 当你要强调一系列相关的产品对象的设计以便进行联合使用时 当你提供一个产品类库,而只想显示它们的接口而不是实现时 UML图 抽象工厂模

抽象工厂(Abstract Factory)

定义 在软件设计中,如果客户想手动创建一个对象,需要知道对象的详细结构,包括其数据结构以及方法调用,如果运气不好,还可能因为该对象引用了其他对象,导致客户端还得了解其他对象,如此..使得该对象的创建变得复杂起来.之前讲过的工厂方法模式可以解决该类问题,不过工厂方法模式一般用来解决单个对象的创建,对于需要创建多个有关联的对象,那么可能就需要使用抽象工厂模式的方法了.此时,客户端只需要知道抽象出来的工厂以及自己所要的对象即可,不必清楚是谁创建以及怎样创建那些具体的对象. 抽象工厂的具体定义为:抽象工

工厂模式[3] 抽象工厂 Abstract Factory

简介 1.简单工厂,或静态工厂,产品接口 定义:专门定义一个类来负责创建其他类的实例,被创建的实例通常具有共同的父类或实现同一接口 优点:客户端可以直接消费产品,而不必关心具体产品的实现(不关心对象的构造方法是怎么new的),消除了客户端直接创建产品对象的责任,实现了对责任的分割. 缺点:工厂类记录了所有产品的创建逻辑,一旦不能正常工作,整个系统都会受到影响:而且当产品种类多.结构复杂的时候,把所有创建工作放进一个工厂中来,会使后期程序的扩展较为困难. 2.工厂方法,工厂接口+产品接口 定义:在

设计模式(3)--抽象工厂模式(Absrtact Factory Pattern)

定义 抽象工厂模式的实质就是提供接口来创建一系列相关或独立的对象而不指定这些对象的具体类. 理解 在软件系统中,经常面临着"一系列相互依赖的对象"的创建工作:同时由于需求的变化,往往存在着更多系列对象的创建工作.如何应对这种变化?如何绕过常规的对象的创建方法(熟悉的new操作符),提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合?这就是我们要说的抽象工厂模式.抽象工厂模式提供了一种方式,可以将一组具有同一主题的单独的工厂

设计模式(三)——抽象工厂模式

设计模式(三)--抽象工厂模式 一.抽象工厂模式 1.抽象工厂模式简介 定义:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类. UML类图: 2.抽象工厂模式角色 (1)抽象工厂AbstractFactory:抽象工厂类,提供创建两种产品的接口CreateProductA和CreateProductB,由派生的各个具体工厂类对其实现 (2)具体工厂:包括具体工厂FactoryM和具体工厂FactoryN.具体工厂FactoryM用于生产具体产品MProductA和具体产品M

设计模式(3)-对象创建型模式-Abstract Factory模式

1.对象创建型模式 1.3           Abstract Factory模式 1.3.1 需求 在下面情况能够使用Abstract Factory模式: ?  一个系统要独立于它的产品的创建.组合和表示时(这个需求和FactoryMethod类似). ?  一个系统要由多个产品系列中的一个来配置时(这个需求也和Factory Method类似). ?  当你要强调一系列相关的产品对象的设计以便进行联合使用时(这个需求表明一个工厂要创建多个相关的产品对象,是比FactoryMethod多的