factory c语言实现设计模式之工厂模式
C++设计模式之一工厂模式（简单工厂、工厂和抽象工厂）
C++设计模式之⼀⼯⼚模式（简单⼯⼚、⼯⼚和抽象⼯⼚）今天开始这个系列之前，⼼⾥有些恐慌，毕竟园⼦⾥的⾼⼿关于设计模式的经典⽂章很多很多，特别是⼤侠、⽼师的⽂章更是堪称经典。
他们的⽂笔如⾏云流⽔，例⼦活泼⽣动，讲解深⼊浅出。
好在他们都是⽤C#描述，也没有提供必要的源码下载，所以我这⾥⽤C++实现。
⾸先我想声明的是我的⽂笔绝对不如他们的好，例⼦也没有他们的形象，不过我打算把C++的代码实现和类图提供给⼤家，就算作为⼀种补充吧。
开始设计模式⾃然⽽然到提到⼏个原则：I、开闭法则（OCP）；II、⾥⽒代换法则（LSP）；III、依赖倒置法则(DIP)；IV、接⼝隔离法则（ISP）；V、合成/聚合复⽤原则（CARP）；VI、迪⽶特法则（LoD），这⼏个法则在⽼师的和中有⾮常详尽的阐述和深⼊浅出的举例分析。
有兴趣的朋友打开链接看⼀下就可以了。
补充说明：我这⾥所以代码都是⽤VS2005的C++编译器实现。
所以不能保证在其他IDE中能顺利编译，但是我想如果你使⽤其他编译器，也应该不会有太⼤问题，主要也应该是stdafx.h⽂件中包含的头⽂件问题。
⾥⾯出⾏的结构图都是⽤微软的Visio2003 绘制，⼤家下载后可以直接⽤Visio打开。
在以后所有的模式例⼦中都有客户程序，客户程序这个⾓⾊不是模式本⾝的内容，它是模式之外的部分，但是正是这个客户程序完成了对模式的使⽤，模式本⾝的结构是讲解的重点，但是客户程序如何使⽤模式也是理解模式的⼀个重要⽅⾯，因此在我后续的介绍中都有客户程序这个⾓⾊，并会说明究竟调⽤模式中的哪些⾓⾊完成对模式的使⽤。
简单⼯⼚模式⽣活例⼦吃饭是⼈的基本需求，如果⼈类不需要吃饭，可能我们就能活得清闲许多，也就不需要像现在⼀样没⽇没夜的⼯作，学习。
我们学习是为了找到更好的⼯作，好⼯作为了赚更多的钱，最终为了吃饱饭，吃好饭。
因此可以说吃饭是与⼈息息相关，下⾯就从吃饭的例⼦来引⼊⼯⼚模式的学习。
如果你想吃饭了，怎么办⾃⼰做吗？⾃⼰做就相当于程序中直接使⽤new。
设计模式之工厂模式
设计模式之工厂模式在软件开发中，面对复杂的系统结构和繁琐的代码实现，我们通常都会采用设计模式来提高软件开发的效率和质量。
设计模式是指在某些经典问题上，经过多次实践、总结和抽象出来的一系列通用的解决方案。
其中，工厂模式是比较常见的一种设计模式。
一、什么是工厂模式工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。
工厂模式能够在创建对象时把这个过程封装起来，从而使客户端不需要知道具体创建的逻辑。
通俗一点说，就是有一个工厂类，根据不同的需求生产不同的产品。
工厂模式的应用场景比较广泛，例如 JDK 中的 Calendar 和 NumberFormat 类，还有Spring 框架中的 BeanFactory 和 ApplicationContext。
二、工厂模式的分类工厂模式一般分为三种：简单工厂模式、工厂方法模式和抽象工厂模式。
1. 简单工厂模式简单工厂模式又叫静态工厂方法，它是指由一个工厂类负责创建多种类型的对象。
客户端只需要提供必要的参数，由工厂类根据参数来生成相应的对象。
简单工厂模式的优点是生产出的对象在客户端中有些封装，客户端只需要知道自己需要什么产品即可，而不需要知道产品的具体实现细节。
以汽车生产为例来说明简单工厂模式的实现。
我们假设汽车生产线只生产轿车、越野车和卡车三种类型的车辆，我们可以使用简单工厂模式实现这个过程。
首先，定义一个车辆抽象类 Vehicle，包含一个 abstract 方法run，表示车辆运行的方法。
然后，分别定义 Car、SUV 和 Truck三个子类，它们分别实现了 run 方法。
abstract class Vehicle {public abstract void run();}class Car extends Vehicle {public void run() {System.out.println("轿车在高速公路上行驶！");}}class SUV extends Vehicle {public void run() {System.out.println("越野车在山路上行驶！");}}class Truck extends Vehicle {public void run() {System.out.println("卡车在某地工地上拉货！");}}接下来，我们创建一个简单的工厂类 CarFactory，它包含一个静态方法 getVehicle，根据客户端传递的参数来创建不同的类型车辆。
面向对象程序设计中的工厂模式探究
面向对象程序设计中的工厂模式探究随着软件开发的不断发展，面向对象程序设计（Object-Oriented Programming，OOP）已经成为了主流的软件开发方法。
而在OOP中，设计模式（Design Pattern）则是众多程序员口中的关键字之一。
其中，工厂模式（Factory Pattern）更是设计模式中的一个经典案例。
那么，什么是工厂模式？在OOP中，它的作用是什么？下文将对这些问题进行探究。
一、什么是工厂模式？工厂模式是一种创建性模式，它可以通过一个工厂方法（Factory Method）根据参数的不同，返回不同类的实例。
它属于面向对象程序设计中的创建型模式，由工厂角色、抽象产品角色、具体产品角色三个要素构成。
具体来讲，工厂角色是核心的部分，负责创建一个或多个具体产品角色的实例。
抽象产品角色是所有具体产品角色的父类，它定义了所有具体产品角色的通用接口。
具体产品角色则是抽象产品角色的实现类。
二、工厂模式的作用是什么？相比其他创建型模式，工厂模式的最大价值在于解耦。
由于具体的产品实现类被“封装”在一个工厂角色中，客户端代码不需要知道要创建哪个具体产品类，而只需要知道它们的共同接口即可。
这样就可以在需要更改产品种类或者添加新的产品的时候不影响客户端程序的实现。
除此之外，工厂模式还能提高代码的可重用性和可维护性。
如果将一些复杂的实例化逻辑（比如必须传入相关上下文参数）直接放到其他类里面，不仅代码重复度高，而且修改起来非常麻烦。
而相反，通过工厂模式将实例化逻辑分离出来，可以将创建对象的代码统一放到工厂角色类中，这样有利于代码的重用和维护。
三、工厂模式的实现方式有哪些？在实际开发中，有很多种方式可以实现工厂模式。
下面分别介绍几种常见的方式。
1. 简单工厂模式简单工厂模式（Simple Factory Pattern）是工厂模式的一种，它通常由一个工厂类负责创建所有的产品类实例。
简单工厂模式中不定义抽象工厂类，而是将具体创建的工作交给一个工厂类来完成。
常见设计模式的解析和实现(C++)整理版
delete cf1; delete cf2; return 0; }
常见设计模式的解析和实现（C++)之三-Builder 模式
作用： 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
ConcreateProductB1() { cout<<"ConcreateProductB1"<<endl; } virtual ~ConcreateProductB1(){} }; //派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现 class ConcreateProductB2:public AbstractProductB { public: ConcreateProductB2() { cout<<"ConcreateProductB2"<<endl; } virtual ~ConcreateProductB2(){} }; //抽象基类AbstractFactory,工厂的抽象类，生产产品A和产品B class AbstractFactory { public: AbstractFactory(){} virtual ~AbstractFactory(){}
解析：
Builder 模式是基于这样的一个情况:一个对象可能有不同的组成部分,这几个部分的不
同的创建对象会有不同的表示,但是各个部分之间装配的方式是一致的.比方说一辆单
车，都是由车轮车座等等的构成的(一个对象不同的组成部分),不同的品牌生产出来的也 不一样(不同的构建方式).虽然不同的品牌构建出来的单车不同,但是构建的过程还是一 样的(哦,你见过车轮长在车座上的么？).也就是说,Director::Construct 函数中固定 了各个组成部分的装配方式,而具体是装配怎样的组成部分由 Builreator::FactoryMethod:纯虚函数,由派生类实现,创建出对应的 Product.
C#设计模式工厂模式
∙简单工厂（Simple Factory）模式∙工厂方法（Factory Method）模式∙抽象工厂（Abstract Factory）模式一、简单工厂（Simple Factory）模式Simple Factory模式根据提供给它的数据，返回几个可能类中的一个类的实例。
通常它返回的类都有一个公共的父类和公共的方法。
Simple Factory模式实际上不是GoF 23个设计模式中的一员。
二、 Simple Factory模式角色与结构：工厂类角色Creator (LightSimpleFactory)：工厂类在客户端的直接控制下（Create方法）创建产品对象。
抽象产品角色Product (Light)：定义简单工厂创建的对象的父类或它们共同拥有的接口。
可以是一个类、抽象类或接口。
具体产品角色ConcreteProduct (BulbLight, TubeLight)：定义工厂具体加工出的对象。
三、程序举例：using System;public abstract class Light{public abstract void TurnOn();public abstract void TurnOff();}public class BulbLight : Light{public override void TurnOn(){Console.WriteLine("Bulb Light is Turned on");}public override void TurnOff(){Console.WriteLine("Bulb Light is Turned off");}}public class TubeLight : Light{public override void TurnOn(){Console.WriteLine("Tube Light is Turned on");}public override void TurnOff(){Console.WriteLine("Tube Light is Turned off");}}public class LightSimpleFactory{public Light Create(string LightType){if(LightType == "Bulb")return new BulbLight();else if(LightType == "Tube")return new TubeLight();elsereturn null;}}public class Client{public static void Main(){LightSimpleFactory lsf = new LightSimpleFactory();Light l = lsf.Create("Bulb");l.TurnOn();l.TurnOff();Console.WriteLine("-----------------");l = lsf.Create("Tube");l.TurnOn();l.TurnOff();}}四、 Simple Factory模式演化Simple Factory模式演化（一）除了上面的用法外，在有些情况下Simple Factory可以由抽象产品角色扮演，一个抽象产品类同时是子类的工厂。
面向对象设计与Factory模式
过度依赖抽象
抽象工厂模式过度依赖抽象，可能 导致代码的可读性和可维护性降低。
难以测试
由于抽象工厂模式涉及到多个层次 的依赖，族的对象，并且这些产品族之 间没有依赖关系。
2
系统需要在不修改现有代码的情况下灵活地添加 新的产品族。
3
需要对多个产品族进行独立测试和调试。
定义一个或多个具体工厂类， 继承自抽象工厂类，并实现工 厂方法，返回具体类的实例。
客户端代码通过调用具体工厂 类的工厂方法获取所需对象， 无需关心对象的创建过程。
优缺点分析
优点
客户端代码与具体类的实现解耦，客 户端只需关心抽象工厂类和抽象产品
类。
增加了代码的灵活性和可扩展性，可 以通过增加新的具体工厂类和具体产 品类来扩展系统。
优缺点分析
优点
代码结构清晰，易于维护和扩展。
工厂类封装了创建对象的逻辑，降低了代码耦合 度。
优缺点分析
• 通过工厂方法返回具体产品实例，实现了 对客户端的透明化。
优缺点分析
01
缺点
02 如果产品种类繁多，会导致工厂类膨胀， 维护困难。
03
工厂类承担了过多的创建对象职责，违反 了单一职责原则。
04
面向对象设计与Factory模 式
• 面向对象设计基础 • Factory模式简介 • 简单Factory模式 • 工厂方法模式（Factory Method） • 抽象工厂模式（Abstract Factory）
01
面向对象设计基础
对象与类
对象
现实世界中的事物或概念在程序 中的表示。
类
对象的抽象，定义了对象的属性 和方法。
当需要提供一种机制，使得客户端代码可以通过统一的方式获
设计模式Factory_Method_工厂方法
Factory Method（工厂方法）Factory Method（工厂方法）属于创建型模式，利用工厂方法创建对象实例而不是直接用 New 关键字实例化。
理解如何写出工厂方法很简单，但理解为什么要用工厂方法就需要动动脑子了。
工厂方法看似简单的将 New 替换为一个函数，其实是体现了面向接口编程的思路，它创建的对象其实是一个符合通用接口的通用对象，这个对象的具体实现可以随意替换，以达到通用性目的。
意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
Factory Method 使一个类的实例化延迟到其子类。
举例子如果看不懂上面的意图介绍，没有关系，设计模式需要在日常工作里用起来，结合例子可以加深你的理解，下面我准备了三个例子，让你体会什么场景下会用到这种设计模式。
换灯泡我自己在家换过灯泡，以前我家里灯坏掉的时候，我看着这个奇形怪状的灯管，心里想，这种灯泡和这个灯座应该是一体的，市场上估计很难买到适配我这个灯座的灯泡了。
结果等我把灯泡拧下来，跑到门口的五金店去换的时候，店员随便给了我一个灯泡，我回去随便拧了一下居然就能用了。
我买这个灯泡的过程就用到了工厂模式，而正是得益于这种模式，让我可以方便在家门口就买到可以用的灯泡。
卡牌对战游戏卡牌对战中，卡牌有一些基本属性，比如攻防、生命值，也符合一些通用约定，比如一回合出击一起等等，那么对于战斗系统来说，应该怎样实例化卡牌呢？如何批量操作卡牌，而不是通用功能也要拿到每个卡牌的实例才能调用？另外每个卡牌有特殊能力，这些特殊能力又应该如何拓展呢？实现任意图形拖拽系统一个可以被交互操作的图形，它可以用鼠标进行拉伸、旋转或者移动，不同图形实现这些操作可能并不相同，要存储的数据也不一样，这些数据应该独立于图形存储，我们的系统如果要对接任意多的图形，具备强大拓展能力，对象关系应该如何设计呢？意图解释在使用工厂方法之前，我们就要创建一个用于创建对象的接口，这个接口具备通用性，所以我们可以忽略不同的实现来做一些通用的事情。
[架构设计]设计模式C 实现 工厂方法模式
![[架构设计]设计模式C 实现 工厂方法模式](https://img.taocdn.com/s3/m/98b62f1652ea551810a687c5.png)
模式定义：工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。
工厂方法让类把实例化推迟到子类。
模式结构：Creator是一个类，它实现了所有操纵产品的方法，但不实现工厂方法。
Creator的所有子类都必须实现工厂方法（factoryMethod()），以实际制造出产品。
所有的产品必须实现Product基类，这样一来使用这些产品的类就可以引用这个基类，而不是派生类。
举例：披萨店希望能够开一些加盟店。
经营者希望确保加盟店运营的质量，所以希望这些店都使用能经过实践考研的代码。
问题在于每家加盟店都可能想要提供不同风味的披萨（比方说纽约，芝加哥，加州），这收到了开店地点及该地区披萨口味的影响。
解决办法：让每个区域风味的披萨工厂继承基类披萨工厂使披萨工厂的订单系统不变，然后创建自己风味的披萨。
这样真正选购披萨类型，使用具体的披萨工厂决定的。
类图设计：编程实现及执行结果：[cpp]view plaincopy1.#include<iostream>2.#include<string>3.#include<list>ing namespace std;首先创建Pizza类[cpp]view plaincopy1.class Pizza2.{3.public:4.Pizza(string nam,string doug,string sauc)5.{=nam;7.dough=doug;8.sauce=sauc;9.}10.void addTops(string tops)11.{12.toppings.push_back(tops);13.}14.15.void prepare()16.{17.cout<<"Preparing"<<name<<endl;18.cout<<"Tossing dough"<<endl;19.cout<<"Adding sauce"<<endl;20.cout<<"Adding toppings"<<endl;21.list<string>::iterator iter=toppings.begin();22.for(;iter!=toppings.end();++iter)23.{24.cout<<""<<*iter;25.}26.cout<<endl;27.}28.29.void bake()30.{31.cout<<"Bake for25minutes at350"<<endl;32.}33.34.void cut()35.{36.cout<<"Cutting the pizza into diagonal slices"<<endl;37.}38.39.void box()40.{41.cout<<"Place pizza in offical PizzaStore box"<<endl;42.}43.44.string getName()45.{46.return name;47.}48.49.private:50.string name;51.string dough;52.string sauce;53.list<string>toppings;54.};然后创建纽约cheese风格的pizza类和纽约clam风格的pizza类[cpp]view plaincopy1.class NYStyleCheesePizza:public Pizza2.{3.public:4.NYStyleCheesePizza():Pizza("NY Style Sauce and Cheese Pizza",5."Thin Crust Dough","Marinara Sauce")6.{7.addTops("Grated Reggiano Cheese");8.}9.};10.class NYStyleClamPizza:public Pizza11.{12.public:13.NYStyleClamPizza():Pizza("NY Style Sauce and Clam Pizza",14."Thin Crust Dough","Marinara Sauce")15.{16.addTops("Grated Clam");17.}18.};创建基类工厂[cpp]view plaincopy1.class PizzaStore2.{3.public:4.virtual~PizzaStore(){}5.6.Pizza*oderPizza(string type)7.{8.Pizza*pizza=createPizza(type);9.pizza->prepare();10.pizza->bake();11.pizza->cut();12.pizza->box();13.14.return pizza;15.}16.17.virtual Pizza*createPizza(string type){return NULL;}18.19.};创建具体类工厂（纽约pizza工厂）[cpp]view plaincopy1.class NYPizzaStore:public PizzaStore2.{3.public:4.Pizza*createPizza(string item)5.{6.if(item=="cheese")7.{8.return new NYStyleCheesePizza();9.}10.else if(item=="clam")11.{12.return new NYStyleClamPizza();13.}14.else15.return NULL;16.}17.};18.//...创建其他地区工厂...客户代码：[cpp]view plaincopy1.int main()2.{3.PizzaStore*nyStore=new NYPizzaStore();4.Pizza*pizza=nyStore->oderPizza("cheese");5.cout<<"Ethan ordered a"<<pizza->getName()<<endl;6.7.return0;8.}执行结果：PreparingNY Style Sauce and Cheese Pizza TossingdoughAddingsauceAddingtoppingsGrated Reggiano CheeseBakefor25minutes at350Cuttingthe pizza into diagonal slices Placepizza in offical PizzaStore box Ethanordered a NY Style Sauce and Cheese Pizza请按任意键继续...设计原则的应用：设计原则6：依赖倒置原则（Dependency Inversion Priciple）：要依赖抽象，不要依赖具体类。
设计模式之工厂模式之工厂方法（php实现）
设计模式之⼯⼚模式之⼯⼚⽅法（php实现）github:git@:ZQCard/design_pattern.git/*** ⼯⼚⽅法* 使⽤开闭原则来分析下⼯⼚⽅法模式。
当有新的产品产⽣时，只要按照抽象产品⾓⾊、抽象⼯⼚⾓⾊提供的合同来⽣成，* 那么就可以被客户使⽤，⽽不必去修改任何已有的代码。
（即当有新产品时，只要创建并基础抽象产品；新建具体⼯⼚继承抽象⼯⼚；* ⽽不⽤修改任何⼀个类）⼯⼚⽅法模式是完全符合开闭原则的！*/(1)IShape.class.php(抽象接⼝,⽤于规定实现类规范)<?phpnamespace Factory\FactoryMethod;interface IShape{public function draw();}(2)AbstractShape.class.php(抽象⽗类,⽤于规范⼦类实现)<?phpnamespace Factory\FactoryMethod;abstract class AbstractShape{public abstract function getShape();}(3)CircleFactory.class.php(具体⼯⼚类,⽤于实现指定⼦类)<?phpnamespace Factory\FactoryMethod;class CircleFactory extends AbstractShape{public function getShape(){return new CirCle();}}(4)Circle.class.php(具体实现类)<?phpnamespace Factory\FactoryMethod;class CirCle{public function draw(){return '画⼀个圆形';}}(5)factoryMethod.php（客户端）<?phpspl_autoload_register(function ($className){$className = str_replace('\\','/',$className);include$className.".class.php";});use \Factory\FactoryMethod\CircleFactory;$factory = new CircleFactory();$shape = $factory->getShape();$string = $shape->draw();echo$sting;优点:遵守开闭原则缺点:增加⼀个产品,需要增加2个类。
工厂模式简述
public class BMW { public BMW(){ System.out.println("这是-->BMW"); }}public class AUDI { public AUDI(){ System.out.println("这是-->AUDI"); }}public class {public static void main(String[] args) { BMW bmw = new BMW(); AUDI audi = new AUDI();}}public interface Car { public void carBrand();}public class AUDI implements Car { @Override public void carBrand() { System.out.println("这是-->AUDI"); }⼯⼚模式简述代码的优化离不开设计模式的使⽤，今天主要介绍⼀下⼯⼚模式：⼯⼚模式概念 实例化对象，⽤⼯⼚⽅法代替new操作 ⼯⼚模式包括⼯⼚⽅法模式、抽象⼯⼚模式什么情况⽤有⼀组相似的对象要创建编码时不能预见创建哪⼀些实例考虑代码的拓展性低耦合，⼀个对象的改变不影响以来他的对象具体实例模拟需求：需要⽣产宝马、奔驰、奥迪原始的做法：存在BMW、AUDI个类，通过new的⽅式创建多个对象客户需要知道怎么去创建⼀款车,客户和车就紧密耦合在⼀起了.为了降低耦合,就出现了⼯⼚类,把创造车的操作细节都放到了⼯⼚⾥⾯去,客户直接使⽤⼯⼚的创建⼯⼚⽅法,传⼊想要的车型号就⾏了,⽽不必去知道创建的细节.这就是⼯业⾰命了：简单⼯⼚模式即我们建⽴⼀个⼯⼚类⽅法来制造新的对象产品类： }}public class BMW implements Car{ @Override public void carBrand() { System.out.println("这是-->BMW"); }}⼯⼚类public class CarFactory {public Car creatCar(String carType){ switch (carType ) { case "bmw": return new BMW(); case "audi": return new AUDI(); default: break; } return null; }}客户端public class Test {CarFactory factory = new CarFactory(); factory.creatCar("bmw"); factory.creatCar("audi");}简单⼯⼚模式⼜称静态⼯⼚⽅法模式。
C++------简单工厂模式，工厂方法模式和抽象工厂模式
C++------简单⼯⼚模式，⼯⼚⽅法模式和抽象⼯⼚模式1，设计模式 设计模式是软件开发⼈员在软件开发过程中⾯临的⼀般问题的解决⽅案。
这些解决⽅案是众多软件开发⼈员经过相当长的⼀段时间的试验和错误总结出来的。
2.设计模式原则 1）开闭原则（Open Close Principle） 开闭原则的意思是：对扩展开放，对修改关闭。
在程序需要进⾏拓展的时候，不能去修改原有的代码。
2）⾥⽒代换原则（Liskov Substitution Principle） ⾥⽒代换原则是⾯向对象设计的基本原则之⼀。
⾥⽒代换原则中说，任何基类可以出现的地⽅，⼦类⼀定可以出现。
LS⾥⽒代换原则是对开闭原则的补充。
实现开闭原则的关键步骤就是抽象化，⽽基类与⼦类的继承关系就是抽象化的具体实现，所以⾥⽒代换原则是对实现抽象化的具体步骤的规范。
3）依赖倒转原则（Dependence Inversion Principle） 这个原则是开闭原则的基础，具体内容：针对接⼝编程，依赖于抽象⽽不依赖于具体。
4）接⼝隔离原则（Interface Segregation Principle） 使⽤多个隔离的接⼝，⽐使⽤单个接⼝要好。
它还有另外⼀个意思是：降低类之间的耦合度。
由此可见，其实设计模式就是从⼤型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
5）迪⽶特法则，⼜称最少知道原则（Demeter Principle） 最少知道原则是指：⼀个实体应当尽量少地与其他实体之间发⽣相互作⽤，使得系统功能模块相对独⽴。
6）合成复⽤原则（Composite Reuse Principle） 合成复⽤原则是指：尽量使⽤合成/聚合的⽅式，⽽不是使⽤继承。
.3.简单⼯⼚模式 简单⼯⼚模式是由⼀个⼯⼚对象决定创建出哪⼀种产品类的实例。
例如： 有⼀家⽣产处理核的⼚家，它只有⼀个⼯⼚，能够⽣产两种型号的处理器核。
客户需要什么样的处理器，⼀定要显⽰地告诉⽣产⼯⼚。
C#设计模式系列：工厂方法模式（FactoryMethod）
C#设计模式系列：⼯⼚⽅法模式（FactoryMethod）1. ⼯⼚⽅法模式简介1. ⼯⼚⽅法模式简介1.1 定义 ⼯⼚⽅法模式定义⼀个⽤于创建对象的接⼝，让⼦类决定实例化哪⼀个类。
⼯⼚⽅法模式是以⼀个类的实例化延迟到其⼦类。
Factory Method模式⽤于在不指定待创建对象的具体类的情况下创建对象。
Factory Method模式的主要意图是隐藏对象创建的复杂性。
Client通常不指定要创建的具体类，Client将⾯向接⼝或抽象类进⾏编码，让Factory类负责创建具体的类型。
通常Factory类有⼀个返回抽象类或者接⼝的静态⽅法。
Client通常提供某种信息让Factory类使⽤提供的信息来确定创建并返回哪个⼦类。
将创建⼦类的责任抽象出来的好处是允许Client完全⽆需考虑依赖类是如何创建的，这遵守依赖倒置原则（Dependency Inversion Principle，DIP）。
Factory Method模式另外⼀个好处是把负责对象创建的代码集中起来，如果需要修改对象⽣成⽅式，可以轻松定位并更新，⽽不会影响到依赖它的代码。
在⾯向对象编程中，⼀般⽅法是⽤⼀个new操作符产⽣⼀个对象的实例。
但是在⼀些情况下，⽤new操作符直接⽣成对象会带来⼀些问题。
⾸先，要使⽤new运算符创建⼀个对象必须清楚所要创建的对象的类信息，包括类名、构造函数等，⽽有时并不现实。
其次许多类型的对象创建需要⼀系列的步骤，可能需要计算或取得对象的初始设置，选择⽣成那个⼦对象实例，或在⽣成需要的对象之前必须⽣成⼀些辅助功能的对象。
在这些情况下，新对象的建⽴就是⼀个过程，⽽不是⼀个简单的操作。
为轻松⽅便地完成复杂对象的创建，从⽽引⼊了⼯⼚模式。
1.2 使⽤频率 ⾼2. ⼯⼚⽅法模式结构2.1 结构图2.2 参与者 ⼯⼚⽅法模式参与者： Product：Product⾓⾊，定义⼯⼚⽅法所创建的对象的接⼝ ConcreteProduct：具体Product⾓⾊，实现Product接⼝ Factory ° 抽象的⼯⼚⾓⾊，声明⼯⼚⽅法，该⽅法返回⼀个Product类型的对象 ° Factory可以定义⼀个⼯⼚⽅法的默认实现，返回⼀个默认的ConcreteProduct对象。
设计模式之创建类模式——工厂方法模式
设计模式之创建类模式——工厂方法模式通用类图：工厂方法模式的优点：1.良好的封装性，代码结构清晰。
一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。
2.工厂方法模式的扩展性非常优秀。
在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。
3.屏蔽产品类。
这一点非常重要，产品类的实现如何变化，调用者都不需要关系，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化。
因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。
4.工厂方法模式是典型的解耦框架。
高层模块只需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换父类也没问题。
工厂方法模式的使用场景：1.工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，到那时需要慎重考虑是否要增加一个工厂类进行管理，增加代码的复杂度。
2.需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。
3.工厂方法模式可以用在异构项目中。
4.可以使用在测试驱动开发的框架下。
工厂方法模式的扩展：缩小为简单工厂模式简单工厂模式（Simple Factory Pattern），也叫做静态工厂模式。
在实际项目中，采用该方法的案例还是比较多的，其缺点是工厂类的扩展比较困难，不符合开闭原则，但它仍然是一个非常实用的设计模式。
类图：升级为多个工厂类多工厂模式中，每一个产品类都对应一个创建类，好处就是创建类的职责清晰，而且结构简单，但是给可扩展性和可维护性带来了一定的影响。
为什么这么说呢？如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。
C#设计模式——简单工厂模式、工厂模式和抽象工厂模式
C#设计模式——简单⼯⼚模式、⼯⼚模式和抽象⼯⼚模式⼀：简单⼯⼚模式 1：描述：简单⼯⼚模式是由⼀个⼯⼚对象根据接收到的消息决定要创建哪⼀个类的对象事例。
2：优点：⼯⼚类中有相关逻辑判断，可以根据需要动态创建相关的对象事例，⽽客户端只需要告诉⼯⼚类创建什么对象事例，⽽不关⼼怎么创建，当需要引⼊新产品就不需要修改客户端的代码，只需要添加相应的产品类并修改⼯⼚类就可以，所以从产品的⾓度上简单⼯⼚模式是符合“开-闭”原则的。
3：缺点：很容易违反⾼内聚低耦合的原则，⼀旦添加新产品就不得不修改⼯⼚逻辑，当产品类型较多时，有可能造成⼯⼚逻辑⽐较复杂，不利于系统的扩展和维护，所以从⼯⼚的⾓度来说简单⼯⼚模式是不符合“开-闭”原则的。
4：例⼦：namespace SimpleFactoryDemo{class Program{static void Main(string[] args){ShapeFactory shapeFactory = new ShapeFactory();shapeFactory.getShape("circle").draw();shapeFactory.getShape("rectangle").draw();shapeFactory.getShape("square").draw();Console.ReadKey();}}public interface IShape{void draw();//默认公共⽅法}public class Circle : IShape{public void draw(){Console.WriteLine("画个圆");}}public class Rectangle : IShape{public void draw(){Console.WriteLine("画个长⽅形");}}public class Square : IShape{public void draw(){Console.WriteLine("画个正⽅形");}}public class ShapeFactory//形状⼯⼚{public IShape getShape(string type){if ("circle".Equals(type)){return new Circle();}else if ("rectangle".Equals(type)){return new Rectangle();}else if ("square".Equals(type)){return new Square();}else{return null;}}}}⼆：⼯⼚模式 1：描述：定义⼀个创建对象的⼯⼚接⼝，让⼦类决定实例化哪个类，将实际创建⼯作推迟到⼦类中。
C__工厂模式
最近一直在看设计模式，想把自己的学习笔记与大家分享一下，如果能帮助大家的话，我会非常高兴，同时也欢迎大家指出里面的不足。
园子里其实关于此类文章已经很多了，如果dudu感觉放在首页欠妥的话，可以调一下。
简单工厂模式（Simple Factory Pattern）介绍：简单工厂模式不能说是一个设计模式，说它是一种编程习惯可能更恰当些。
因为它至少不是Gof23种设计模式之一。
但它在实际的编程中经常被用到，而且思想也非常简单，可以说是工厂方法模式的一个引导，所以我想有必要把它作为第一个讲一下。
引入：我们在编程的时候，每当"new"一个对象之后，这个对象就依赖于这个类了。
如果在后期的维护过程中由于某些原因需要修改一下这个类，则唯一的做法就是打开源代码，进行修改，修改所有与这个对象有关的操作。
这对我们是非常不利的。
问题出来了：对象不能应对“具体实例化类型”的变化解决思路：套用一下李建忠李老师的话，封装变化点，哪里变化，封装哪里。
在这个例子中，要实例化的类变了，就将实例化这个操作封装起来，我们可以把"new"这个操作移交一个具体的类，由它去负责根据我们的条件创建具体类的实例，也就是下面要说的“简单工厂模式”。
定义：专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类或接口。
简单工厂模式又称为静态工厂方法（Static Factory Method）模式，属于类的创建型模式，通常根据一个条件（参数）来返回不同的类的实例。
意图：提供一个类，由它负责根据一定的条件创建某一具体类的实例参与者：∙工厂角色（Creator）是简单工厂模式的核心，它负责实现创建所有具体产品类的实例。
工厂类可以被外界直接调用，创建所需的产品对象。
∙抽象产品角色（Product）是所有具体产品角色的父类，它负责描述所有实例所共有的公共接口。
具体产品角色（Concrete Product）继承自抽象产品角色，一般为多个，是简单工厂模式的创建目标。
C#设计模式之工厂模式
C#设计模式之⼯⼚模式这是我们⽤得⽐较多的⼀种设计模式，也是23种标准设计模式之⼀，使⽤前⾯讲的简单⼯⼚设计模式，遇到具体产品经常变换时就不太适合了，违反了开闭设计原则；怎么才能避免修改⼯⼚类呢？⼯⼚⽅法模式可以做到。
⼯⼚⽅法模式要求我们应该有⼀个抽象的⼯⼚类，我们知道尽量使⽤抽象类或接⼝来定义就可以达到⼀个开闭原则的效果，这样我们在抽象的⼯⼚类定义⼀个⽣产产品的⽅法，这个⽅法就是⼯⼚⽅法，这也是⼯⼚⽅法模式的由来，他具体的⾏为会有他的⼦类或实现类来实现。
如果想⽣产某种产品，就定义⼀个新的产品，新的产品⼯⼚类，这样就实现了不同的产品进⾏⼀个不同的创建，这样如果有信的产品，只需要添加新的⼯⼚类，原来写好的代码不会发⽣变化，这种⽅式符合开闭原则，可扩展⽐较好。
添加⼀个具体产品，只需要在添加⼀个具体产品的⼯⼚类实现抽象⼯⼚类，不需要修改原来的代码⽰例代码：抽象产品类：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ⼯⼚模式{/*动物抽象类* 抽象产品*/public abstract class Animal{public abstract void Eat();}}抽象⼯⼚类：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace ⼯⼚模式{/*动物抽象⼯⼚类*/public abstract class AnimalFactory{public abstract Animal GetAnimal();}}⽣产狗的具体⼯⼚类：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace ⼯⼚模式{/// <summary>/// 具体⼯⼚：⽣成狗/// </summary>public class DogFactory :AnimalFactory{public override Animal GetAnimal(){return new Dog();}}}⽣产企鹅的具体⼯⼚类：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace ⼯⼚模式{/// <summary>/// 具体⼯⼚：⽣成企鹅/// </summary>public class PenguinFactory :AnimalFactory {public override Animal GetAnimal(){return new Penguin();}}}具体产品狗类：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;/*具体的产品类，实现抽象产品类*/public class Dog:Animal{// 实现抽象⽅法public override void Eat(){Console.WriteLine("狗在吃饭！");}}}具体产品企鹅类：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace ⼯⼚模式{/*具体产品类，实现抽象产品类*/public class Penguin : Animal{// 实现抽象⽅法public override void Eat(){Console.WriteLine("企鹅在吃饭!");}}}客户端调⽤：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace ⼯⼚模式{class Program{static void Main(string[] args){AnimalEat(new DogFactory());Console.ReadKey();}static void AnimalEat(AnimalFactory af) {Animal am = af.GetAnimal();am.Eat();}}}类图：如果想在增加⼀个Cat类，只需要增加⼀个具体的Cat类实现Animal类的⽅法，增加⼀个具体的Cat⼯⼚类实现抽象⼯⼚类即可，不需要在修改已经写好的代码，符合开闭原则。
factoryc语言实现设计模式之工厂模式
factoryc语言实现设计模式之工厂模式/** 工厂模式* 想要扩展加盟店，只需要在FactoryInit增加不同地域风味的pizza创建方式* 不同地域风味的pizza店想要增加口味，只要pfPZCreate 中增加风味**/typedef enum tag_PZ_TYPE_E{PZ_CHEESE,PZ_PEPPERON,PZ_CLAM,PZ_VEGGIE}PZ_TYPE_E;typedef enum tag_PZ_STYLE_E{NY_STYLE_E,CHI_STYLE_E}PZ_STYLE_E;typedef struct tag_PIZZA_S{void (*pfPrepare)(void);void (*pfBake)(void);void (*pfCut)(void);void (*pfBox)(void);}PIZZA_S;typedef PIZZA_S * (*PF)(PZ_TYPE_E);typedef struct tag_PZ_FACTORY_S{PF pfPZCreate;BOOLEAN (*pfPZDelete)(PIZZA_S **);}PZ_FACTORY_S;typedef struct tag_PZ_STORE_S{PZ_STYLE_E eStyle;PZ_TYPE_E eType;PZ_FACTORY_S stFactory;BOOLEAN (*pfFactoryInit)(PZ_FACTORY_S *,struct tag_PZ_STORE_S *);BOOLEAN (*pfOrderPZ)(INT8U ,PIZZA_S **,struct tag_PZ_STORE_S *);}PZ_STORE_S;/************************************************************** ********************************************* Function name: PreparePZ** Descriptions:** input parameters:**** output parameters:** Returned value:***************************************************************** ******************************************/void PreparePZ(void){printf("prepare pizza");}void BakePZ(void){printf("bake pizza")}void CutPZ(void){printf("cut pizza")}void BoxPZ(void){printf("Box pizza")}/************************************************************** ********************************************* Function name: FactoryInit** Descriptions: 工厂初始化** input parameters:**** output parameters:** Returned value:***************************************************************** ******************************************/BOOLEAN FactoryInit(PZ_FACTORY_S *pstFactory,struct tag_PZ_STORE_S *pstStore ){if ((NULL == pstFactory)||(NULL == pstStore)){return FALSE;}if (NY_STYLE_E == pstStore->eStyle){pstFactory->pfPZCreate = NYStylePizzaCreate;pstFactory->pfPZDelete = PizzaDelete;}else if (CHI_STYLE_E == pstStore->eStyle){pstFactory->pfPZCreate = ChiStylePizzaCreate;pstFactory->pfPZDelete = PizzaDelete;}return TRUE;}/************************************************************** ********************************************* Function name: PizzaFactoryCreate** Descriptions: 创建newyork 风味pizza** input parameters: eType pizza类型**** output parameters:** Returned value: pizza指针******************************************************************************************************* ****/PIZZA_S * NYStylePizzaCreate(PZ_TYPE_E eType){PIZZA_S *pstPizza = (PIZZA_S*)malloc(sizeof(PIZZA_S));if (NULL == pstPizza){/* print err */}pstPizza->pfPrepare = PreparePZ;pstPizza->pfBake = BakePZ;pstPizza->pfCut = CutPZ;pstPizza->pfBox = BoxPZ;if (PZ_CHEESE == eType){printf("ny style cheese pizza");}else if (PZ_PEPPERON == eType){printf("ny style pepperon pizza");}else if (PZ_CLAM == eType){printf("ny sytle clam pizza");}else if (PZ_VEGGIE == eType){printf("ny style vegie pizza");}return pstPizza;}/************************************************************** ********************************************* Function name: ChiStylePizzaCreate** Descriptions: 创建chicago 风味pizza** input parameters: eType pizza类型**** output parameters:** Returned value: pizza指针***************************************************************** ******************************************/PIZZA_S * ChiStylePizzaCreate(PZ_TYPE_E eType){PIZZA_S *pstPizza = (PIZZA_S*)malloc(sizeof(PIZZA_S));if (NULL == pstPizza){/* print err */}pstPizza->pfPrepare = PreparePZ;pstPizza->pfBake = BakePZ;pstPizza->pfCut = CutPZ;pstPizza->pfBox = BoxPZ;if (PZ_CHEESE == eType){printf("chi style cheese pizza");}else if (PZ_PEPPERON == eType){printf("chi style pepperon pizza");}else if (PZ_CLAM == eType){printf("chi style clam pizza");}else if (PZ_VEGGIE == eType){printf("chi style veggie pizza");}return pstPizza;}/************************************************************** ********************************************* Function name: PizzaFactoryDelete** Descriptions: 销毁pizza实例** input parameters: ppstPizza 已存在的pizza实例**** output parameters: true 销毁成功 false 销毁失败** Returned value:***************************************************************** ******************************************/BOOLEAN PizzaDelete(PIZZA_S **ppstPizza){/* 入参检查 */if (NULL == ppstPizza){return FALSE;}if (NULL != *ppstPizza){free(*ppstPizza);*ppstPizza = NULL;}return TRUE;}/************************************************************** ********************************************* Function name: orderPizza** Descriptions: pizza订单** input parameters: ppstPizza 生产的pizza**** output parameters: true订单生成成功， false失败** Returned value:***************************************************************** ******************************************/BOOLEAN orderPizza(PIZZA_S **ppstPizza,struct tag_PZ_STORE_S *pstStore){PIZZA_S *pstback = NULL;/* 入参检查 */if (NULL == ppstPizza){return FALSE;}pstStore->pfFactoryInit(&pstStore->stFactory,pstStore);*ppstPizza = pstStore->stFactory.pfPZCreate(pstStore->eType);pstback = *ppstPizza;if (NULL == pstback){return FALSE;}pstback->pfPrepare();pstback->pfBake();pstback->pfCut();pstback->pfBox();return TRUE;}void PizzaTestDrive(void){PZ_STORE_S NYStylePZStore;PZ_STORE_S ChicagoStylePZStore;PIZZA_S *pNyStylePZ = NULL;PIZZA_S *pChiStylePZ = NULL;NYStylePZStore.eStyle = NY_STYLE_E;NYStylePZStore.eType = PZ_CHEESE;NYStylePZStore.pfOrderPZ = orderPizza;NYStylePZStore.pfFactoryInit = FactoryInit;ChicagoStylePZStore.eStyle = CHI_STYLE_E;ChicagoStylePZStore.eType = PZ_CLAM;ChicagoStylePZStore.pfOrderPZ = orderPizza;ChicagoStylePZStore.pfFactoryInit = FactoryInit;NYStylePZStore.pfOrderPZ(&pNyStylePZ,NYStylePZStore);NYStylePZStore.stFactory.pfPZDelete(&pNyStylePZ);ChicagoStylePZStore.pfOrderPZ(&pChiStylePZ,ChicagoStyle PZStore);ChicagoStylePZStore.stFactory.pfPZDelete(&pChiStylePZ);}。
C++工厂设计模式教程
C++工厂设计模式工厂模式是我们日常最常见的一种创建型设计模式了，它提供了一种创建对象的最佳方式，在工厂模式中，我们在创建对象时，不会在客户端暴露创建逻辑，并且使用一个共同的接口来指向新创建的对象。
工厂模式的优点：1：一个调用者想创建一个对象，只要知道其名称就可以了。
2：扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3：屏蔽产品的具体实现，调用者只关心产品的接口。
工厂模式的缺点：1：每增加一个产品时，都需要增加一个产品具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖，这并不是什么好事儿。
适用场景：1.工厂模式的目的是为了实现解耦，将对象的创建和使用分开，即应用程序将对象的创建和初始化职责交给工厂对象。
若一个对象A想要调用对象B时，如果直接通过new关键字来创建一个B实例，然后调用B实例，这样做的不好处是，当需求变更，要将B实例换成C实例时，则需要修改所有new了该实例的方法。
2.降低代码重复。
如果对象B的创建过程比较复杂，并且很多地方都用到了，那么很可能出现很多重复的代码，通过统一将创建对象B的代码放到工厂里面统一管理，可以减少代码的重复率，同时也方便维护。
相比于构造函数来说，复杂的初始化，会使得构造函数非常的复杂。
由于创建过程都由工厂统一的管理，有利于当业务发生变化之后的修改3.工厂模式将创建和使用分离，使用者不需要知道具体的创建过程，只需要使用即可。
4.类本身有很多子类，并且经常性发生变化。
创建对象需要大量重复的代码。
创建对象需要访问某些信息，而这些信息不应该包含在复合类中。
创建对象的生命周期必须集中管理，以保证在整个程序中具有一致的行为。
工厂模式分类：工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式三种。
下边是三种工厂模式的具体实现。
一、简单工厂模式：主要特点是需要在工厂类中做出判断，从而创造相应的产品，当增加新产品时，需要修改工厂类。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
/*********************************************************************************************************
** Function name: PreparePZ
}
else if (PZ_VEGGIE == eType)
{
printf("ny style vegie pizza");
}
return pstPizza;
}
/*********************************************************************************************************
** Returned value:
**
** Descriptions: 创建newyork 风味pizza
** input parameters: eType pizza类型
**
** output parameters:
** Returned value: pizza指针
}
else if (PZ_PEPPERON == eType)
{
printf("ny style pepperon pizza");
}
else if (PZ_CLAM == eType)
{
printf("ny sytle clam pizza");
PZ_CLAM,
PZ_VEGGIE
}PZ_TYPE_E;
typedef enum tag_PZ_STYLE_E
{
NY_STYLE_E,
CHI_STYLE_E
}PZ_STYLE_E;
typedef struct tag_PIZZA_S
{
void (*pfPrepare)(void);
{
printf("chi style cheese pizza");
}
else if (PZ_PEPPERON == eType)
{
printf("chi style pepperon pizza");
}
else if (PZ_CLAM == eType)
/*
* 工厂模式
* 想要扩展加盟店，只需要在FactoryInit增加不同地域风味的pizza创建方式
* 不同地域风味的pizza店想要增加口味，只要pfPZCreate 中增加风味
*
*/
typedef enum tag_PZ_TYPE_E
{
PZ_CHEESE,
PZ_PEPPERON,
}
if (NY_STYLE_E == pstStore->eStyle)
{
pstFactory->pfPZCreate = NYStylePizzaCreate;
pstFactory->pfPZDelete = PizzaDelete;
}
/*********************************************************************************************************
** Function name: PizzaFactoryDelete
}
else if (CHI_STYLE_E == pstStore->eStyle)
{
pstFactory->pfPZCreate = ChiStylePizzaCreate;
pstFactory->pfPZDelete = PizzaDelete;
BOOLEAN FactoryInit(PZ_FACTORY_S *pstFactory,struct tag_PZ_STORE_S *pstStore )
Hale Waihona Puke { if ((NULL == pstFactory)||(NULL == pstStore))
{
return FALSE;
** Descriptions: 销毁pizza实例
** input parameters: ppstPizza 已存在的pizza实例
**
** output parameters: true 销毁成功 false 销毁失败
** output parameters:
** Returned value: pizza指针
**
*********************************************************************************************************/
pstPizza->pfBake = BakePZ;
pstPizza->pfCut = CutPZ;
pstPizza->pfBox = BoxPZ;
if (PZ_CHEESE == eType)
{
printf("ny style cheese pizza");
PZ_FACTORY_S stFactory;
BOOLEAN (*pfFactoryInit)(PZ_FACTORY_S *,struct tag_PZ_STORE_S *);
BOOLEAN (*pfOrderPZ)(INT8U ,PIZZA_S **,struct tag_PZ_STORE_S *);
}
void BakePZ(void)
{
printf("bake pizza")
}
void CutPZ(void)
{
printf("cut pizza")
}
void BoxPZ(void)
{
printf("Box pizza")
}
/*********************************************************************************************************
PIZZA_S * ChiStylePizzaCreate(PZ_TYPE_E eType)
{
PIZZA_S *pstPizza = (PIZZA_S*)malloc(sizeof(PIZZA_S));
if (NULL == pstPizza)
{
/* print err */
** Returned value:
**
*********************************************************************************************************/
{
printf("chi style clam pizza");
}
else if (PZ_VEGGIE == eType)
{
printf("chi style veggie pizza");
}
return pstPizza;
** Descriptions:
** input parameters:
**
** output parameters:
** Returned value:
**
{
PIZZA_S *pstPizza = (PIZZA_S*)malloc(sizeof(PIZZA_S));
if (NULL == pstPizza)
{
/* print err */
}
pstPizza->pfPrepare = PreparePZ;
*********************************************************************************************************/
void PreparePZ(void)
{
printf("prepare pizza");
** Function name: FactoryInit
** Descriptions: 工厂初始化
** input parameters:
**
** output parameters:
**
*********************************************************************************************************/
PIZZA_S * NYStylePizzaCreate(PZ_TYPE_E eType)
{
PF pfPZCreate;
BOOLEAN (*pfPZDelete)(PIZZA_S **);
}PZ_FACTORY_S;
typedef struct tag_PZ_STORE_S
{
PZ_STYLE_E eStyle;
PZ_TYPE_E eType;
}
pstPizza->pfPrepare = PreparePZ;
pstPizza->pfBake = BakePZ;