Rule Mode C ++ implementation

First look at the UML class diagram of the Policy mode:

 

The class diagram shows that there is no difference between the policy mode and the simple factory mode. From my understanding, the two major differences are:The simple factory mode is used to realize the diversity of objects, while the policy mode is suitable for class members to focus on methods. The simple factory mode can only solve the problem of object creation, and the policy mode should be used for frequently changing algorithms.

 

Let's take a look at the Code:

CPP Code

1. // Policy base class
2. ClassCoperation
3. {
4. Public:
5. IntM_nfirst;
6. IntM_nsecond;
7. Virtual DoubleGetresult ()
8. {
9. DoubleDresult = 0;
10. ReturnDresult;
11. }
12. };
14. // Policy-specific class-addition class
15. ClassAddoperation:PublicCoperation
16. {
17. Public:
18. Addoperation (IntA,IntB)
19. {
20. M_nfirst =;
21. M_nsecond = B;
22. }
23. Virtual DoubleGetresult ()
24. {
25. ReturnM_nfirst + m_nsecond;
26. }
27. };
29. ClassContext
30. {
31. Private:
32. Coperation * op;
33. Public:
34. Context (coperation * temp)
35. {
36. OP = temp;
37. }
38. DoubleGetresult ()
39. {
40. ReturnOp-> getresult ();
41. }
42. };
44. // Client
45. IntMain ()
46. {
47. IntA, B;
48. CharC;
49. Cin> A> B;
50. Cout <"Enter the operator :;
51. Cin> C;
52. Switch(C)
53. {
54. Case'+ ':
55. Context * context =NewContext (NewAddoperation (a, B ));
56. Cout <context-> getresult () <Endl;
57. Break;
58. Default:
59. Break;
60. }
61. Return0;
62. }

// Policy base class coperation {public: int m_nfirst; int m_nsecond; virtual double getresult () {double dresult = 0; return dresult ;}}; // policy-specific class-addition class addoperation: Public coperation {public: addoperation (int A, int B) {m_nfirst = A; m_nsecond = B;} virtual double getresult () {return m_nfirst + m_nsecond ;}; class context {PRIVATE: coperation * op; public: Context (coperation * temp) {op = temp;} double getresult () {return op-> getresult () ;};// client int main () {int A, B; char C; CIN >>>a> B; cout <"Enter the operator:; CIN> C; Switch (c) {Case '+': Context * context = new context (New addoperation (a, B )); cout <context-> getresult () <Endl; break; default: break;} return 0 ;}

For convenience, I only put an addition class here. You can inherit a subtraction, multiplication, and so on, and then add the relevant classification in the main function switch. Here, we also see the policy MethodDisadvantages: All operations are judged on the client, and the customer's tasks are added.

As we all know, the simple factory model is just to concentrate all the judgment operations on the factory class, so we can think of combining the two models, and the following model emerged-the combination of strategy and factory model, the code is modified based on the above Code:

CPP Code

1. ClassContext
2. {
3. Private:
4. Coperation * op;
5. Public:
6. Context (CharCtype)
7. {
8. Switch(Ctype)
9. {
10. Case'+ ':
11. OP =NewAddoperation (3, 8 );
12. Break;
13. Default:
14. OP =NewAddoperation ();
15. Break;
16. }
17. }
18. DoubleGetresult ()
19. {
20. ReturnOp-> getresult ();
21. }
22. };
23. // Client
24. IntMain ()
25. {
26. IntA, B;
27. Cin> A> B;
28. Context * test =NewContext ('+ ');
29. Cout <Test-> getresult () <Endl;
30. Return0;
31. }

Class context {PRIVATE: coperation * op; public: Context (char ctype) {Switch (ctype) {Case '+': op = new addoperation (3,8); break; default: OP = new addoperation (); break ;}} double getresult () {return op-> getresult () ;}; // client int main () {int A, B; cin> A> B; Context * test = new context ('+'); cout <Test-> getresult () <Endl; return 0 ;}