设计模式之简单工厂模式学习

        学习C++有一两年了，面向对象思想也有所接触。使用过MFC以及OSG类库进行过开发，无非就是调用别人设计好的类库，要说自己使用面向对象的思想去开发程序，这个还真没有。意识到自己在这方面的匮乏，开始学习设计模式。教材选用《大话设计模式》，每个章节的学习过程分为三部分：第一部分，阅读课本，第二部分：按照书上例子写出C++代码的对应版本。第三部分：博客上的学习笔记。

 

     编程是一门技术，更是一门艺术。应该经常考虑如何使代码更加简练、可扩展、可复用和易维护。这是每个立志于成为合格程序员都应具有的素质。这些东西学校不教，只有通过从大量编程中总结教训获得经验。

     通过封装继承多态，把程序的耦合性降低，使程序更加的灵活、容易修改、易于复用。业务逻辑与界面逻辑分开，让他们的耦合度降低，只有这样才能达到可维护和易扩展。

     1：可维护：只需改要改之处，此为可维护性

     2：可复用：并非仅供一个工程内使用，以后在其他项目时也可以方便的使用。此为可复用。

     3：可扩展：若要添加功能，只需在原有基础上添加即可，此为可扩展。

     4：灵活性：不拘泥于一种形式。此为灵活性。

     大话设计模式在介绍简单工厂模式时介绍了一个计算器的例子，引出了初学者容易犯的几个问题：知道面向对象，但是究竟好在哪里、如何更好地使用它却无从知晓。

     学习设计模式四境界：

     一：没学之前一点儿都不懂，根本想不到用设计模式，设计的代码很糟糕。

     二：学了几个设计模式很开心，于是到处想着用自己学过的设计模式，时常造成误用设计模式而不自知。

     三：学完设计模式后，感觉诸多模式极其相似，无法分清模式之间的差异。有困惑，但深知误用之害，应用之时有所犹豫。

     四：灵活应用设计模式，甚至不应用某种具体的模式也能写出优秀的代码，已达到无剑胜有剑的境界。

         希望自己能早日进入第四个境界，达到无剑胜有剑的境界。奋斗

     在例子中，加减乘除派生自一个基类，该基类定义了公有的属性以及虚函数接口。在各个派生类中实现了每个派生类中需要的功能。除此之外还定义了简单工厂类，在简单工厂类中，根据运算符决定需要实例化那个运算功能类。

看代码：

 
  1. 1.#include<iostream>  
2.usingnamespace std;  

1.//基类  
2.class Calculation  
3.{  
4.   public:  
5.   Calculation(double n1,double n2)  
6.   :num1(n1),num2(n2)  
7.   {  
8.     
9.   };  
10.   Calculation()  
11.   :num1(0),num2(0)  
12.   {  
13.     
14.   };  
15.   ~Calculation()  
16.   {  
17.      
18.   }  
19.   virutal double calculate()=0;  
20.   double num1;  
21.   double num2;  
22.};

     

 
  1. 1.//加法  

1.class AddCalculation:public Calculation  
2.{  
3.    AddCalculation(double n1,double n2)  
4.    :Calculation(n1,n2)  
5.    {  
6.          
7.    }  
8.    AddCalculation()  
9.    {  
10.         
11.    }  
12.    ~AddCalculation()  
13.    {  
14.         
15.    }  
16.    virtualdouble calculate()  
17.    {  
18.        return num1+num2;  
19.    }  
20.      
21.      
22.} ;  


class AddCalculation:public Calculation
{
    AddCalculation(double n1,double n2)
    :Calculation(n1,n2)
    {
        
    }
    AddCalculation()
    {
       
    }
    ~AddCalculation()
    {
       
    }
    virtual double calculate()
    {
        return num1+num2;
    }
    
    
} ;

     

  1. 1.//减法  

1.class Substract:public Calculation  
2.{  
3.    public:  
4.    Substract(double n1,double n2)  
5.    :Calculation(n1,n2)  
6.    {  
7.          
8.    }  
9.    Substract()  
10.    {  
11.          
12.    }  
13.    ~Substract()  
14.    {  
15.          
16.    }  
17.    virtualdouble calculate()  
18.    {  
19.        return num1-num2;  
20.    }   
21.      
22.} ;

     

    //乘法  

1.class Multiply:public:Calculation  
2.{  
3.public:  
4.    Multiply(double n1,doule n2)  
5.    :Calculaion(n1,n2)  
6.    {  
7.          
8.    }  
9.    Multiply()  
10.    {  
11.    }  
12.    ~Multiply()  
13.    {  
14.          
15.    }   
16.    virtualdouble calculate()  
17.    {  
18.        return num1*num2;  
19.    }  
20.      
21.};

     

 

  1. 1.//除法  

1.class Divide:public Calculation  
2.{  
3.    public:  
4.    Diviede(double n1,double n2)  
5.    :Calculation(n1,n2)  
6.    {  
7.          
8.    }   
9.    Divide()  
10.    {  
11.          
12.    }  
13.    ~Divide()  
14.    {  
15.          
16.    }  
17.    virtualdouble calculate()  
18.    {  
19.        if(num2==0)  
20.        {  
21.              
22.        }  
23.        return num1/num2;   
24.    }  
25.      
26.      
27.};

     

 

  1. 1.//抽象工厂类 

1.class OperationFactory  
2.{  
3.    public:  
4.    OperationFactory(double n1,char op,double n2)  
5.    {  
6.        Operator=op;  
7.        num1=n1;  
8.        num2=n2;  
9.        cal=NULL;  
10.    }  
11.    ~OperationFactory()  
12.    {  
13.        if(cal)  
14.            delete cal;  
15.    }  
16.    char Operator;  
17.    Calculation * cal;  
18.    double result;  
19.    double n1;  
20.    double n2;  
21.    double  createCalculation()  
22.    {  
23.        switch(Operator)  
24.        {  
25.            case'+':  
26.            {  
27.                cal=new AddCalculation(n1,n2);  
28.            }  
29.            break;  
30.            case'-':  
31.            {  
32.                cal=new Substract(n1,n2);  
33.            }  
34.            break;  
35.            case'*':  
36.            {  
37.                cal=new Multiply(n1,n2);  
38.            }  
39.            break;  
40.            case'/':  
41.            {  
42.                cal=new Divide(n1,n2);  
43.                  
44.            }  
45.            break;  
46.            default:  
47.            break;   
48.        }  
49.        result=cal->calculate();  
50.    }  
51.      
52.};  
53.int main(int argc,char**argv)  
54.{  
55.    double n1,n2;  
56.    while(cin>>n1>>n2);  
57.    {  
58.  
59.        OperationFactory opf(n1,'+',n2);  
60.        cout<<opf.createCalculation()<<endl;  
61.                  
62.    }  
63.    return 0;  
64.}

     

posted on 2012-05-09 21:53  ithzhang  阅读(206)  评论(0)    收藏  举报

导航