Design pattern C + + implementation (1)--Factory mode

Design patterns in the field of software provide developers with an effective way to use expert design experience. The design pattern uses the important characteristic of object-oriented programming language: encapsulation, inheritance, polymorphism, really comprehend the essence of design pattern is probably a long process, need to accumulate a lot of practical experience. Recently read the design pattern of the book, for each model, with C + + write a small example, deepen understanding. The main reference is "Big talk design mode" and "design pattern: The basis of reusable object-oriented software" two books. This article describes the implementation of the factory pattern.

The factory model belongs to the creation model, which can be divided into three types, simple Factory mode, factory method mode and abstract Factory mode. That sounds almost like a factory model. The following introduction, the first introduction of the Simple factory model, its main feature is the need to make judgments in the factory class, so as to create the corresponding products. When adding new products, you need to modify the factory class. A little abstract, for example, I understand. There is a manufacturer of processor cores, which has only one factory, capable of producing two types of processor cores. What kind of processor core the customer needs, be sure to show to the production plant. The following is an implementation scenario.

[CPP]View Plaincopyprint?

2. Enum CTYPE {corea, Coreb};
4. Class Singlecore
6. {
8. Public
10. virtual void Show () = 0;
12. };
14. Single Core A
16. Class Singlecorea: Public singlecore
18. {
20. Public
22. void Show () {cout<<"Singlecore A" <<endl;}
24. };
26. Single Core B
28. Class Singlecoreb: Public singlecore
30. {
32. Public
34. void Show () {cout<<"Singlecore B" <<endl;}
36. };
38. The only factory that can produce two types of processor cores, in-house judgment
40. Class Factory
42. {
44. Public
46. singlecore* Createsinglecore (enum CTYPE CTYPE)
48. {
50. if (ctype = = Corea) //Factory internal judgment
52. return new Singlecorea (); //production of nuclear a
54. Else if (ctype = = Coreb)
56. return new Singlecoreb (); //production of nuclear b
58. Else
60. return NULL;
62. }
64. };

The main drawbacks of this design have been mentioned before, that is, to add new kernel types, you need to modify the factory class. This violates the open closure principle: Software entities (classes, modules, functions) can be extended, but cannot be modified. So, the factory method pattern appeared. The so-called factory method pattern refers to defining an interface for creating objects, so that subclasses decide which class to instantiate. The Factory method defers the instantiation of a class to its subclasses.

It sounds abstract, or it is explained in the example just now. The producer of the processor's core made a lot of money and decided to set up another factory dedicated to the B-type single-core, and the original factory was designed to produce a single core of type A. At this point, the customer to do is to find a good factory, such as to a model of the nuclear, to find a factory to, or to find the B factory, no longer need to tell the factory specifically what type of processor core. Here is an implementation scenario.

[CPP]View Plaincopyprint?

2. Class Singlecore
4. {
6. Public
8. virtual void Show () = 0;
10. };
12. Single Core A
14. Class Singlecorea: Public singlecore
16. {
18. Public
20. void Show () {cout<<"Singlecore A" <<endl;}
22. };
24. Single Core B
26. Class Singlecoreb: Public singlecore
28. {
30. Public
32. void Show () {cout<<"Singlecore B" <<endl;}
34. };
36. Class Factory
38. {
40. Public
42. virtual singlecore* createsinglecore () = 0;
44. };
46. Production of a nuclear plant
48. Class Factorya: Public Factory
50. {
52. Public
54. singlecorea* Createsinglecore () { return new Singlecorea;}
56. };
58. Plant producing B-core
60. Class Factoryb: Public Factory
62. {
64. Public
66. singlecoreb* Createsinglecore () { return new Singlecoreb;}
68. };

Factory method models also have drawbacks, and each additional product requires an additional plant for the object. If the company develops rapidly and launches many new processor cores, it will have to open a new plant. In the C + + implementation, it is to define a factory class. Obviously, the factory method pattern requires more class definitions than the simple factory model.

Given the simple factory model and the factory approach model, why should there be an abstract factory model? How does it work? To cite this example, the company's technology continues to evolve, not only to produce single-core processors, but also to produce multicore processors. Both the simple Factory mode and the factory method mode are now beyond. The abstract factory model has appeared. It is defined to provide an interface that creates a series of related or interdependent objects without specifying their specific classes. In this application, the company also opened two factories, one dedicated to the production of a single core multi-core processor, and another factory dedicated to the production of B-type single-core multicore processors, the implementation of the code below.

[CPP]View Plaincopyprint?

2. Single Core
4. Class Singlecore
6. {
8. Public
10. virtual void Show () = 0;
12. };
14. Class Singlecorea: Public singlecore
16. {
18. Public
20. void Show () {cout<<"single Core A" <<endl;}
22. };
24. Class Singlecoreb: Publicsinglecore
26. {
28. Public
30. void Show () {cout<<"single Core B" <<endl;}
32. };
34. Multi-core
36. Class multicore
38. {
40. Public
42. virtual void Show () = 0;
44. };
46. Class Multicorea: Public multicore
48. {
50. Public
52. void Show () {cout<<"Multi Core A" <<endl;}
56. };
58. Class Multicoreb: Public multicore
60. {
62. Public
64. void Show () {cout<<"Multi Core B" <<endl;}
66. };
68. Factory
70. Class Corefactory
72. {
74. Public
76. virtual singlecore* createsinglecore () = 0;
78. virtual multicore* createmulticore () = 0;
80. };
82. Factory A, designed to produce a type a processor
84. Class Factorya: Publiccorefactory
86. {
88. Public
90. singlecore* Createsinglecore () { return new Singlecorea ();}
92. multicore* Createmulticore () { return new Multicorea ();}
94. };
96. Factory B, dedicated to the production of B-type processors
98. Class Factoryb: Public corefactory
100. {
102. Public
104. singlecore* Createsinglecore () { return new Singlecoreb ();}
106. multicore* Createmulticore () { return new Multicoreb ();}
108. };

At this point, the factory model is finished. Use rational Rose 2003 software to give a UML diagram of three factory models to deepen impressions.

UML diagram for simple Factory mode:

UML diagram of the factory method:

UML diagram for abstract Factory mode:

I enjoy the copyright of the blog article, reproduced please indicate the source http://blog.csdn.net/wuzhekai1985

Design pattern C + + implementation (1)-Factory mode (RPM)