工厂模式、抽象工厂、简单工厂

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，也就是说工厂方法模式让实例化推迟到子类。

工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。虽然他很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加。

具体代码如下

#include 
using namespace std;
class SingleCore
{
public:
	virtual void Show() = 0;
};
class SingleCoreA:public SingleCore
{
public:
  void Show()
  {
      cout << "Single Core A" << endl;
  }
};
class SingleCoreB:public SingleCore
{
public:
  void Show()
  {
      cout << "Single Core B" << endl;
  }
};
class Factory
{
public:
  virtual SingleCore* CreateSingleCore() = 0;
};
class FactoryA:public Factory
{
public:
  SingleCore* CreateSingleCore()
  {
      cout << "Create SingleCore A" << endl;
      return new SingleCoreA();
  }
};
class FactoryB:public Factory
{
public:
  SingleCore* CreateSingleCore()
  {
      cout << "Create SingleCore B" << endl;
      return new SingleCoreB();
  }
};
int main()
{
  FactoryA m;
  SingleCore* p = m.CreateSingleCore();
  p->Show();
  FactoryB n;
  p = n.CreateSingleCore();
  p->Show();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，
在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事

抽象工厂模式

抽象工厂模式是指定义一个创建一些列相关或相互依赖的对象接口，而无需指定它们具体的类。

例如：这家公司的技术不断发展，现在可以生产多核的处理器，具体方法：还是开设两个工厂分别用来生产A,B两种型号的处理器。

具体代码如下：

  #include
  using namespace std;
            class SingleCore
            {
            public:
                virtual void Show() = 0;
            };
            class SingleCoreA:public SingleCore
            {
            public:
                void Show()
                {
                    cout << " SingleCoreA"<<endl;
                }
            };
            class SingleCoreB:public SingleCore

            {
            public:
                void Show()
                {
                    cout << " SingleCoreA"<<endl;
                }
            };
            class SingleCoreB:public SingleCore
            {
            public:
                void Show()
                {
                    cout << "SingleCoreB" << endl;
                }
            };

            class MultiCore
            {
            public:
                virtual void Show() = 0;
            };
            class MultiCoreA:public MultiCore
            {
            public:
                void Show()
                {
                    cout << "MultiCoreA" << endl;
                }
            };
            class MultiCoreB:public MultiCore
            {
            public:
                void Show()
                {
                    cout << "MultiCoreB" << endl;
                }
            };
            class CoreFactory
            {
            public:
                virtual SingleCore* createSingleCore() = 0;
                virtual MultiCore* createMultiCore() = 0;
            };

            class CoreFactoryA:public CoreFactory
            {
            public:
                SingleCore* createSingleCore()
                {
                    cout << "create SingleCoreA" << endl;
                    return new SingleCoreA();
                }
                MultiCore* createMultiCore()
                {
                    cout << "create MultiCoreA" << endl;
                    return new MultiCoreA();

                }
            };
            class CoreFactoryB:public CoreFactory
            {
            public:
                SingleCore* createSingleCore()
                {
                    cout << "create SingleCoreB" << endl;
                    return new SingleCoreB();
                }
                MultiCore* createMultiCore()
                {
                    cout << "create MultiCoreB" << endl;
                    return new MultiCoreB();
                }
            };

            int main()
            {
                CoreFactoryB Fcb;
                SingleCore* core = Fcb.createSingleCore();
                MultiCore* Mcore = Fcb.createMultiCore();
                core->Show();
                Mcore->Show();
                CoreFactoryA Fca;
                core = Fca.createSingleCore();
                Mcore = Fca.createMultiCore();
                core->Show();
                Mcore->Show();
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

简单工厂模式

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
例如：有一家生产处理核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器，一定要显示地告诉生产工厂。

缺点： 每增加一个新的产品就需要增加一个对象的工厂

具体代码如下：

 #include
 using namespace std;
            class SingleCore
            {
            public:
                virtual void Show() = 0;
            };
            class SingleCoreA:public SingleCore
            {
            public:
                void Show()
                {
                    cout << "Single Core A" << endl;
                }
            };
            class SingleCoreB:public SingleCore
            {
            public:
                void Show()
                {
                    cout << "Single Core B" << endl;
                }
            };
            class Factory
            {
            public:
                virtual SingleCore* CreateSingleCore() = 0;
            };
            class FactoryA:public Factory
            {
            public:
                SingleCore* CreateSingleCore()
                {
                    cout << "Create SingleCore A" << endl;
                    return new SingleCoreA();
                }
            };
            class FactoryB:public Factory
            {
            public:
                SingleCore* CreateSingleCore()
                {
                    cout << "Create SingleCore B" << endl;
                    return new SingleCoreB();
                }
            };
            int main()
            {
                FactoryA m;
                SingleCore* p = m.CreateSingleCore();
                p->Show();
                FactoryB n;
                p = n.CreateSingleCore();
                p->Show();
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55