工厂模式 - 工厂方法模式、抽象工厂模式

弁言

工厂模式（Factory Pattern）是操持模式中创建型模式的一种，它提供了一种创建对象的最佳方式。工厂模式的焦点头脑是将对象的创建与利用分离，使得代码更加机动、可扩展。工厂模式重要分为两种：工厂方法模式和抽象工厂模式。
本文将具体先容工厂方法模式和抽象工厂模式的概念、实现方式以及在C++中的应用。
工厂方法模式

概念

工厂方法模式（Factory Method Pattern）界说了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式让类的实例化推迟到子类。
长处

• 解耦：将对象的创建与利用分离，低落代码的耦合度。
  
• 扩展性好：新增产物类时，只需增长相应的工厂类，无需修改现有代码。
  
• 符合开闭原则：对扩睁开放，对修改关闭。
  

缺点

• 类的数量增长：每增长一个产物类，就须要增长一个对应的工厂类，导致类的数量增长。
  
• 复杂性增长：对于简单的对象创建，利用工厂方法模式大概会增长代码的复杂性。
  

实现

下面是一个简单的工厂方法模式的实现示例：

2. #include <iostream>
3. #include <string>
5. // 产品接口
6. class Product {
7. public:
8.     virtual ~Product() {}
9.     virtual void use() = 0;
10. };
12. // 具体产品A
13. class ProductA : public Product {
14. public:
15.     void use() override {
16.         std::cout << "Using Product A" << std::endl;
17.     }
18. };
20. // 具体产品B
21. class ProductB : public Product {
22. public:
23.     void use() override {
24.         std::cout << "Using Product B" << std::endl;
25.     }
26. };
28. // 工厂接口
29. class Factory {
30. public:
31.     virtual ~Factory() {}
32.     virtual Product* createProduct() = 0;
33. };
35. // 具体工厂A
36. class FactoryA : public Factory {
37. public:
38.     Product* createProduct() override {
39.         return new ProductA();
40.     }
41. };
43. // 具体工厂B
44. class FactoryB : public Factory {
45. public:
46.     Product* createProduct() override {
47.         return new ProductB();
48.     }
49. };
51. int main() {
52.     Factory* factoryA = new FactoryA();
53.     Product* productA = factoryA->createProduct();
54.     productA->use();
56.     Factory* factoryB = new FactoryB();
57.     Product* productB = factoryB->createProduct();
58.     productB->use();
60.     delete productA;
61.     delete productB;
62.     delete factoryA;
63.     delete factoryB;
65.     return 0;
66. }

复制代码

应用场景

工厂方法模式实用于以了局景：

• 不确定对象的范例：当创建对象时，不确定具体要创建哪种范例的对象。
  
• 须要扩展：当须要扩展体系，增长新的产物类时，利用工厂方法模式可以克制修改现有代码。
  

抽象工厂模式

概念

抽象工厂模式（Abstract Factory Pattern）提供一个创建一系列相干或相互依靠对象的接口，而无需指定它们具体的类。抽象工厂模式是工厂方法模式的扩展，它用于创建一组相干的对象。
长处

• 高内聚：将相干的产物族会合在一起创建，包管产物族的同等性。
  
• 解耦：将产物的创建与利用分离，低落代码的耦合度。
  
• 符合开闭原则：对扩睁开放，对修改关闭。
  

缺点

• 类的数量增长：每增长一个产物族，就须要增长一个对应的工厂类，导致类的数量增长。
  
• 复杂性增长：对于简单的对象创建，利用抽象工厂模式大概会增长代码的复杂性。
  

实现

下面是一个简单的抽象工厂模式的实现示例：

2. #include <iostream>
3. #include <string>
5. // 抽象产品A
6. class AbstractProductA {
7. public:
8.     virtual ~AbstractProductA() {}
9.     virtual void use() = 0;
10. };
12. // 具体产品A1
13. class ProductA1 : public AbstractProductA {
14. public:
15.     void use() override {
16.         std::cout << "Using Product A1" << std::endl;
17.     }
18. };
20. // 具体产品A2
21. class ProductA2 : public AbstractProductA {
22. public:
23.     void use() override {
24.         std::cout << "Using Product A2" << std::endl;
25.     }
26. };
28. // 抽象产品B
29. class AbstractProductB {
30. public:
31.     virtual ~AbstractProductB() {}
32.     virtual void use() = 0;
33. };
35. // 具体产品B1
36. class ProductB1 : public AbstractProductB {
37. public:
38.     void use() override {
39.         std::cout << "Using Product B1" << std::endl;
40.     }
41. };
43. // 具体产品B2
44. class ProductB2 : public AbstractProductB {
45. public:
46.     void use() override {
47.         std::cout << "Using Product B2" << std::endl;
48.     }
49. };
51. // 抽象工厂
52. class AbstractFactory {
53. public:
54.     virtual ~AbstractFactory() {}
55.     virtual AbstractProductA* createProductA() = 0;
56.     virtual AbstractProductB* createProductB() = 0;
57. };
59. // 具体工厂1
60. class ConcreteFactory1 : public AbstractFactory {
61. public:
62.     AbstractProductA* createProductA() override {
63.         return new ProductA1();
64.     }
66.     AbstractProductB* createProductB() override {
67.         return new ProductB1();
68.     }
69. };
71. // 具体工厂2
72. class ConcreteFactory2 : public AbstractFactory {
73. public:
74.     AbstractProductA* createProductA() override {
75.         return new ProductA2();
76.     }
78.     AbstractProductB* createProductB() override {
79.         return new ProductB2();
80.     }
81. };
83. int main() {
84.     AbstractFactory* factory1 = new ConcreteFactory1();
85.     AbstractProductA* productA1 = factory1->createProductA();
86.     AbstractProductB* productB1 = factory1->createProductB();
87.     productA1->use();
88.     productB1->use();
90.     AbstractFactory* factory2 = new ConcreteFactory2();
91.     AbstractProductA* productA2 = factory2->createProductA();
92.     AbstractProductB* productB2 = factory2->createProductB();
93.     productA2->use();
94.     productB2->use();
96.     delete productA1;
97.     delete productB1;
98.     delete factory1;
99.     delete productA2;
100.     delete productB2;
101.     delete factory2;
103.     return 0;
104. }

复制代码

应用场景

抽象工厂模式实用于以了局景：

• 产物族：当须要创建一组相干的产物时，利用抽象工厂模式可以包管产物族的同等性。
  
• 跨平台：当须要为差别的平台创建一组相干的产物时，利用抽象工厂模式可以方便地切换平台。
  

总结

工厂模式是一种非常实用的操持模式，它将对象的创建与利用分离，使得代码更加机动、可扩展。工厂方法模式实用于创建单一产物，而抽象工厂模式实用于创建一组相干的产物。在实际开辟中，根据具体需求选择符合的工厂模式，可以进步代码的可维护性和可扩展性。
盼望本文能资助你更好地明确工厂方法模式和抽象工厂模式的概念、实现方式以及应用场景。假如你有任何标题或发起，接待在批评区留言讨论。