C + + policy mode

Policy mode: It defines the algorithm family, which is encapsulated separately, so that they can be replaced with each other, and this pattern will not affect other customers with the change of algorithm.  This mode is actually what we usually write code, in fact, the design pattern is to tell you how to write code, it is not what to move to use the scheme, if so, for the birds do not directly write in the library as a framework call, because it only provides a solution. It just tells you how to write the code when you have similar requirements to it. The code is well-extensible, easy to maintain, and has a low degree of coupling between classes. The strategy model caters to several object-oriented design ideas:1. Find out where changes may be needed in your application, separate them, and don't mix with code that doesn't need to change. 2, multi-use combination, less with inheritance. 3, for the interface and not to implement programming.
Cite the example in Head first design mode: If we want to set up a duck class: in the base class, there are fly (), swim (), quack () These function interfaces, and then in the subclass as long as the implementation of these interfaces is OK. But here's the problem, for example, we're going to implement a "dry duck" and a "rubber duck". You will find that the sense of logic in the design is a little less right, like duck will be called? Does it have a quack () or fly () function interface? And the duck will have swim () method?    These must be wrong. The problem is that this design approach is not quite consistent: 2, multi-use combination, less with inheritance. principles, the use of inheritance is not so flexible.
Or you can design this: it might be a good design, separate fly () and swim out as a class, and then inherit individually, so the design fits:1. Find out where changes may be needed in your application, separate them, and don't mix with code that doesn't need to change. But the Acton class should also be duck, and the action should belong to the Duck class. Separate to inherit, it may not have much effect on the implementation, but it seems logically not very good, as if someone had to "quartered" you.
So, in summary, this design: that is, the action as a member of the duck, and then in its own method to invoke the interface in action.

1. voidDuck::peformfly(){
2. this->action.fly();
3. }

Above the block diagram, the code is implemented.

2. #include<iostream>
4. #include<string>
8. classStratery{
10. public:
12. Stratery(){
16. }
18. virtualvoidAlgorithmInterface(){
20. std::cout<<"AlgorithmInterface"<<std::endl;
22. }
24. };
26. classConcreteStrateryA:publicStratery{
28. public:
30. virtualvoidAlgorithmInterface(){
32. std::cout<<"ConcreteStrateryA"<<std::endl;
34. }
36. };
40. classConcreteStrateryB:publicStratery{
42. public:
44. virtualvoidAlgorithmInterface(){
46. std::cout<<"ConcreteStrateryB"<<std::endl;
48. }
50. };
52. classConcreteStrateryC:publicStratery{
54. public:
56. virtualvoidAlgorithmInterface(){
58. std::cout<<"ConcreteStrateryC"<<std::endl;
60. }
62. };
64. classContext{
66. private:
68. Stratery*stratery;
70. public:
72. Context(Stratery*_stratery):stratery(_stratery){
76. }
78. voidContextInterface(){
80. stratery->AlgorithmInterface();
82. }
84. };
88. int main(){
90. Context contextA(newConcreteStrateryA());
92. contextA.ContextInterface();
94. Context contextB(newConcreteStrateryB());
96. contextB.ContextInterface();
98. Context contextC(newConcreteStrateryB());
100. contextC.ContextInterface();
102. }

The above implementation is the classic use of the policy pattern. which

1. ConcreteStrateryA

1. ConcreteStrateryB

1. ConcreteStrateryC

is the algorithm family. There is no coupling between these algorithms. This is also one of the key points of the strategy model. It can be said that the policy pattern is used to encapsulate the algorithm, but it can also be extended to all other requirements similar to the class. For example, in the preceding Duck class, the algorithm encapsulated in the Duck class is the action.

Null

C + + policy mode