设计模式|集合2（工厂法）-yiteyi-C++库

工厂法是一种创意设计模式，即与对象创建相关。在Factory模式中，我们在不向客户机公开创建逻辑的情况下创建对象，客户机使用相同的公共接口创建新类型的对象。

null

其思想是使用静态成员函数（静态工厂方法），创建并返回实例，向用户隐藏类模块的细节。工厂模式是创建对象的核心设计原则之一，它允许客户机以不与库的类层次结构紧密耦合的方式创建库的对象（如下所述）。

当我们谈论 图书馆 客户呢？ 库是由第三方提供的，它公开了一些公共API，客户端调用这些公共API来完成任务。一个非常简单的例子是Android操作系统提供的不同类型的视图。 为什么是工厂模式？ 让我们用一个例子来理解它：

C

                         // A design without factory pattern                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         // Library classes                       
                         class                                     Vehicle {                       
                         public                                     :                       
                                                 virtual                                     void                                     printVehicle() = 0;                       
                         };                       
                         class                                     TwoWheeler :                                     public                                     Vehicle {                       
                         public                                     :                       
                                                 void                                     printVehicle()  {                       
                                                 cout <<                                     "I am two wheeler"                                     << endl;                       
                                                 }                       
                         };                       
                         class                                     FourWheeler :                                     public                                     Vehicle {                       
                                                 public                                     :                       
                                                 void                                     printVehicle()  {                       
                                                 cout <<                                     "I am four wheeler"                                     << endl;                       
                                                 }                       
                         };                       
           
                         // Client (or user) class                       
                         class                                     Client {                       
                         public                                     :                       
                                                 Client(                                     int                                     type)  {                       
           
                                                 // Client explicitly creates classes according to type                       
                                                 if                                     (type == 1)                       
                                                 pVehicle =                                     new                                     TwoWheeler();                       
                                                 else                                     if                                     (type == 2)                       
                                                 pVehicle =                                     new                                     FourWheeler();                       
                                                 else                       
                                                 pVehicle = NULL;                       
                                                 }                       
           
                                                 ~Client()   {                       
                                                 if                                     (pVehicle)                       
                                                 {                       
                                                 delete                                     [] pVehicle;                       
                                                 pVehicle = NULL;                       
                                                 }                       
                                                 }                       
           
                                                 Vehicle* getVehicle() {                       
                                                 return                                     pVehicle;                       
                                                 }                       
                         private                                     :                       
                                                 Vehicle *pVehicle;                       
                         };                       
           
                         // Driver program                       
                         int                                     main() {                       
                                                 Client *pClient =                                     new                                     Client(1);                       
                                                 Vehicle * pVehicle = pClient->getVehicle();                       
                                                 pVehicle->printVehicle();                       
                                                 return                                     0;                       
                         }                       

输出：

I am two wheeler

什么是 问题在于 这个 高于设计？ 正如您在上面的示例中所看到的，客户机在构建其对象的过程中根据一些输入创建TwoWheeler或FourWheeler对象。比如说，图书馆引入了一种新的三轮车，将三轮车也纳入其中。会发生什么？客户端将在条件阶梯中链接一个新的else if，以创建三轮车对象。这反过来又需要重新编译客户端。因此，每次在库端进行新的更改时，客户机都需要在其末尾进行一些相应的更改并重新编译代码。听起来很糟糕？这是一种非常糟糕的设计实践。

如何避免这个问题？ 答案是，创建一个静态（或工厂）方法。让我们看看下面的代码。

C

                         // C++ program to demonstrate factory method design pattern                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         enum                                     VehicleType {                       
                                                 VT_TwoWheeler,    VT_ThreeWheeler,    VT_FourWheeler                       
                         };                       
           
                         // Library classes                       
                         class                                     Vehicle {                       
                         public                                     :                       
                                                 virtual                                     void                                     printVehicle() = 0;                       
                                                 static                                     Vehicle* Create(VehicleType type);                       
                         };                       
                         class                                     TwoWheeler :                                     public                                     Vehicle {                       
                         public                                     :                       
                                                 void                                     printVehicle() {                       
                                                 cout <<                                     "I am two wheeler"                                     << endl;                       
                                                 }                       
                         };                       
                         class                                     ThreeWheeler :                                     public                                     Vehicle {                       
                         public                                     :                       
                                                 void                                     printVehicle() {                       
                                                 cout <<                                     "I am three wheeler"                                     << endl;                       
                                                 }                       
                         };                       
                         class                                     FourWheeler :                                     public                                     Vehicle {                       
                                                 public                                     :                       
                                                 void                                     printVehicle() {                       
                                                 cout <<                                     "I am four wheeler"                                     << endl;                       
                                                 }                       
                         };                       
           
                         // Factory method to create objects of different types.                       
                         // Change is required only in this function to create a new object type                       
                         Vehicle* Vehicle::Create(VehicleType type) {                       
                                                 if                                     (type == VT_TwoWheeler)                       
                                                 return                                     new                                     TwoWheeler();                       
                                                 else                                     if                                     (type == VT_ThreeWheeler)                       
                                                 return                                     new                                     ThreeWheeler();                       
                                                 else                                     if                                     (type == VT_FourWheeler)                       
                                                 return                                     new                                     FourWheeler();                       
                                                 else                                     return                                     NULL;                       
                         }                       
           
                         // Client class                       
                         class                                     Client {                       
                         public                                     :                       
           
                                                 // Client doesn't explicitly create objects                       
                                                 // but passes type to factory method "Create()"                       
                                                 Client()                       
                                                 {                       
                                                 VehicleType type = VT_ThreeWheeler;                       
                                                 pVehicle = Vehicle::Create(type);                       
                                                 }                       
                                                 ~Client() {                       
                                                 if                                     (pVehicle) {                       
                                                 delete                                     [] pVehicle;                       
                                                 pVehicle = NULL;                       
                                                 }                       
                                                 }                       
                                                 Vehicle* getVehicle()  {                       
                                                 return                                     pVehicle;                       
                                                 }                       
           
                         private                                     :                       
                                                 Vehicle *pVehicle;                       
                         };                       
           
                         // Driver program                       
                         int                                     main() {                       
                                                 Client *pClient =                                     new                                     Client();                       
                                                 Vehicle * pVehicle = pClient->getVehicle();                       
                                                 pVehicle->printVehicle();                       
                                                 return                                     0;                       
                         }                       

输出：

I am three wheeler

在上面的示例中，我们已经将对象创建的类型选择与客户端完全解耦。库现在负责根据输入决定要创建的对象类型。客户端只需要调用库的factory Create方法并传递它想要的类型，而不必担心对象创建的实际实现。

工厂法的其他示例：

比如说，在“绘图”系统中，根据用户的输入，可以绘制不同的图片，如正方形、矩形和圆形。在这里，我们可以使用factory方法根据用户的输入创建实例。要添加新类型的形状，无需更改客户端代码。
另一个例子：在旅游网站上，我们可以预订火车票、公共汽车票和机票。在这种情况下，用户可以将其旅行类型指定为“公共汽车”、“火车”或“航班”。这里我们有一个抽象类“AnyTravel”，带有一个静态成员函数“GetObject”，根据用户的旅行类型，它将创建并返回一个对象“BusTravel”或“TrainTravel”“BusTravel”或“TrainTravel”具有乘客姓名、始发地、目的地参数等常见功能。

进一步阅读： Python中的工厂方法如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章