"Westward Design Model" simple factory pattern

Background to the issue:

　　Problem programming beginners will have such a problem, the problem is encountered with a computer can understand intuitively the logic to be solved and describe the specific solving process, but this program only to meet current needs, not easy to maintain and expand.

Problem-solving ideas:

1. Before designing a piece of code, you first need to take into account its maintainability , scalability ;
2. The object-oriented features fully integrated into the design process the code;

 

calculator.h

 1 #ifndef _CALCULATOR_H_
 2 #define _CALCULATOR_H_
 3 #include <string>
 4 
 5 struct Calculator {
 6     Calculator() = default;
 7     Calculator(double lNum, double rNum) 
 8         :leftNumber(lNum), rightNumber(rNum), result(0){}
 9     ~Calculator(){}
10 
11     virtual double getResult() = 0; //基类中可实现也可不实现
12 protected:
 13 is      Double leftNumber;
 14      Double rightNumber;
 15      Double Result;
 16  };
 . 17  
18 is  / * 
. 19  on inheritance:
 20 is      public - invariant property
 21 is      protected - public becomes protected
 22 is      Private - have become Private
 23 is  * / 
24  class CalculatorAdd: public the Calculator
 25  {
 26 is  public :
 27      CalculatorAdd () = default ;
 28      CalculatorAdd ( Double lNum, double rNum) 
29         :Calculator(lNum, rNum){}
30     ~CalculatorAdd(){};
31     //加
32     virtual double getResult();
33 };
34 class CalculatorSub :public Calculator
35 {
36 public:
37     CalculatorSub() = default;
38     CalculatorSub(double lNum, double rNum) 
39         :Calculator(lNum, rNum){}
40     ~CalculatorSub(){};
41     //减
42     virtual double getResult();
43 };
44 class CalculatorMul :public Calculator
45 {
46 public:
47     CalculatorMul() = default;
48     CalculatorMul(double lNum, double rNum) 
49         :Calculator(lNum, rNum){}
50     ~CalculatorMul(){};
51     //乘
52     virtual double getResult();
53 };
54 class CalculatorDiv :public Calculator
55 {
56 public:
57     CalculatorDiv() = default;
58     CalculatorDiv(double lNum, double rNum)
59         :Calculator(lNum, rNum){}
60     ~CalculatorDiv(){};
61     //除
62     virtual double getResult();
63 };
64 
65 struct FactoryCalculator {
66     FactoryCalculator() = default;
67     FactoryCalculator(std::string op, double num1, double num2);
68     double getResult(){ return p->getResult(); }//简短函数默认inline
69 private:
70     std::string operate;
71     double number1;
72     double number2;
73     Calculator *p;
74 };
75 
76 #endif

View Code

calculator.cpp

. 1 #include " calculator.h " 
2 #include <the iostream>
 . 3  
. 4  the using  namespace STD; // Typically, the using only appear in the source file, and not in the header file 
. 5  
. 6  Double the Calculator :: the getResult ()
 . 7  {
 . 8      COUT << " Message :: Print the getResult in the Calculator " << endl;
 . 9      return  0.0 ;
 10  }
 . 11  
12 is  Double CalculatorAdd the getResult :: ()
 13 is  {
 14      the Calculator :: the getResult (); //我曾经来过
15 
16     result = leftNumber + rightNumber;
17     return result;
18 }
19 double CalculatorSub::getResult()
20 {
21     Calculator::getResult();
22 
23     result = leftNumber - rightNumber;
24     return result;
25 }
26 double CalculatorMul::getResult()
27 {
28     Calculator::getResult();
29 
30     result = leftNumber * rightNumber;
31     return result;
32  }
 33 is  Double CalculatorDiv the getResult :: ()
 34 is  {
 35      the Calculator :: the getResult ();
 36  
37 [      IF (rightNumber == 0 ) {
 38 is          COUT << " Division Not CAN BE ZERO " << endl;
 39          return - . 1 ;
 40      }
 41 is      Result = leftNumber / rightNumber;
 42 is      return Result;
 43 is  }
 44 is  
45  // If the function thereof is too long, then the initialization list are written on the source file (with the initialization list must function body) 
46 FactoryCalculator::FactoryCalculator(string op, double num1, double num2) 
47     :operate(op), number1(num1), number2(num2)
48 {
49     char flag = operate[0];
50     switch (flag)
51     {
52     case '+':
53         p = new CalculatorAdd(number1, number2);
54         break;
55     case '-':
56         p = new CalculatorSub(number1, num2);
57         break;
58     case '*':
59         p = new CalculatorMul(number1, number2);
60         break;
61     case '/':
62         p = new CalculatorDiv(number1, number2);
63         break;
64     default:
65         break;
66     }
67 }

View Code

main.cpp

 1 #include "calculator.h"
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 int main()
 7 {
 8     FactoryCalculator *factoryCalculaotr = new FactoryCalculator("+", 1, 2);
 9     FactoryCalculator *factoryCalculaotr2 = new FactoryCalculator("-", 1, 2);
10     FactoryCalculator *factoryCalculaotr3 = new FactoryCalculator("*", 1, 2);
11     FactoryCalculator *factoryCalculaotr4 = new FactoryCalculator("/", 1, 2);
12     cout << factoryCalculaotr->getResult() << endl;
13     cout << factoryCalculaotr2->getResult() << endl;
14     cout << factoryCalculaotr3->getResult() << endl;
15     cout << factoryCalculaotr4->getResult() << endl;
16 
17     system("pause");
18 }

View Code