C++设计模式之一：Factrory Pattern

Factory模式的两个最重要的功能：

1）定义创建对象的接口，封装对象的创建；

个人见解：核心的主要部分在于一个具体类上，Factory接收到请求自动判断提供什么产品，但是对于一个factory而言，倘若添加一个新的产品，需要做太多的改动，换句话来说，添加一个新的产品必须改动整个factory工厂。

 

 

 

1. #include <iostream>
2. using namespace std;
3. class product
4. {
5. public:
6.  virtual void produce(){};      //具体的实现交给子类的函数；
7.  virtual void sell(){};
8.  product(){};
9.  virtual ~product(){};
10. };
11. class conproduct1:public product
12. {
13. public:
14.  void produce()
15.  {cout<<"Pro conproduct1.."<<endl;}
16.  void sell()
17.  {cout<<"Sel conproduct1.."<<endl;}
18. };
19. class conproduct2:public product
20. {
21. public:
22.  void produce()
23.  {cout<<"Pro conproduct2.."<<endl;}
24.  void sell()
25.  {cout<<"Sel conproduct2.."<<endl;}
26. };
27. class Factory                //具体的操作由factory控制选择
28. {
29. public:
30.  Factory(){}
31.  static product *Creatproduct(int a)
32.  {
33.   if(a==1) {return new conproduct1();}  //生成相对应的pro对象;
34.   if(a==2) {return new conproduct2();}
35.  }
36. };
37. void main()
38. { 
39.  Factory *fac=new Factory();
40.  (fac->Creatproduct(2))->produce();
41. }

2）使得具体化类的工作延迟到子类中

 

个人见解：核心在于一个factory的抽象类。相对于1而言，其解决了增加一个新的产品的简单处理，只需要添加一个新的类以及所对应的处理类就能搞定，不需要改变factory工厂。 但是其缺陷在于，只支持一种PRODUCT基类。

 

1. /*****************/
2. /*** Product.h ***/
3. /*****************/
4. #ifndef _PRODUCT_H
5. #define _PRODUCT_H
6. class Product
7. {
8. public:
9.  virtual ~Product()=0;
10. protected:
11.  Product();
12. private:
13. };
15. class ConcreatProduct:public Product
16. {
17. public:
18.  ~ConcreatProduct();
19.  ConcreatProduct();
20. };
21. #endif
23. /*****************/
24. /** Product.cpp **/
25. /*****************/
26. #include "Product.h"
27. #include
28. using namespace std;
29. Product::Product()
30. {}
31. Product::~Product()
32. {}
33. ConcreatProduct::ConcreatProduct()
34. {
35. cout<<"ConcreatProduct.."<
36. }
37. ConcreatProduct::~ConcreatProduct()
38. {}
40. /*****************/
41. /** Factory.h ****/
42. /*****************/
43. #ifndef _FACTORY_H_
44. #define _FACTORY_H_
45. class Product;
46. class Factory
47. {
48. public:
49.  virtual ~Factory()=0;
50.  virtual Product* CreateProduct()=0;
51. protected:
52.  Factory();
53. };
55. class ConcreatFactory:public Factory
56. {
57. public:
58.  ~ConcreatFactory();
59.  ConcreatFactory();
60.  Product* CreateProduct();
61. };
62. #endif
64. /*****************/
65. /** Factory.cpp **/
66. /*****************/
67. #include "Factory.h"
68. #include "Product.h"
69. #include
70. using namespace std;
71. Factory::Factory()
72. {}
73. Factory::~Factory()
74. {}
75. ConcreatFactory::ConcreatFactory()
76. {
77. cout<<"ConcreatFactory..."<
78. }
79. ConcreatFactory::~ConcreatFactory()
80. {}
81. Product* ConcreatFactory::CreateProduct()
82. {
83.  return new ConcreatProduct();
84. }
86. /*****************/
87. /** Main.cpp *****/
88. /*****************/
89. #include "Factory.h"
90. #include "Product.h"
91. #include
92. using namespace std;
93. void main()
94. {
95. Factory* fac=new ConcreatFactory();
96. Product*p=fac->CreateProduct();
97. }