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

长平狐 发布于 2012/10/08 15:16
阅读 85
收藏 0
         学习C++有一两年了,面向对象思想也有所接触。使用过MFC以及OSG类库进行过开发,无非就是调用别人设计好的类库,要说自己使用面向对象的思想去开发程序,这个还真没有。

     意识到自己在这方面的匮乏,开始学习设计模式。教材选用《大话设计模式》,每个章节的学习过程分为三部分:第一部分,阅读课本,第二部分:按照书上例子写出C++代码的对应版本。第三部分:博客上的学习笔记。

 

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

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

     1:可维护:只需改要改之处,此为可维护性

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

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

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

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

     学习设计模式四境界:

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

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

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

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

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

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

看代码:

#include<iostream>
using namespace std;
//基类
class Calculation
{
   public:
   Calculation(double n1,double n2)
   :num1(n1),num2(n2)
   {
   
   };
   Calculation()
   :num1(0),num2(0)
   {
   
   };
   ~Calculation()
   {
   	
   }
   virutal double calculate()=0;
   double num1;
   double num2;
};
//加法
class AddCalculation:public Calculation
{
	AddCalculation(double n1,double n2)
	:Calculation(n1,n2)
	{
		
	}
	AddCalculation()
	{
	   
	}
	~AddCalculation()
	{
	   
	}
	virtual double calculate()
	{
		return num1+num2;
	}
	
	
} ;
//减法
class Substract:public Calculation
{
	public:
	Substract(double n1,double n2)
	:Calculation(n1,n2)
	{
		
	}
	Substract()
	{
		
	}
	~Substract()
	{
		
	}
	virtual double calculate()
	{
		return num1-num2;
	} 
	
} ;
//乘法
class Multiply:public:Calculation
{
public:
	Multiply(double n1,doule n2)
	:Calculaion(n1,n2)
	{
		
	}
	Multiply()
	{
	}
	~Multiply()
	{
		
	} 
	virtual double calculate()
	{
		return num1*num2;
	}
	
};
//除法
class Divide:public Calculation
{
	public:
	Diviede(double n1,double n2)
	:Calculation(n1,n2)
	{
		
	} 
	Divide()
	{
		
	}
	~Divide()
	{
		
	}
	virtual double calculate()
	{
		if(num2==0)
		{
			
		}
		return num1/num2; 
	}
	
	
};
//抽象工厂类
class OperationFactory
{
	public:
	OperationFactory(double n1,char op,double n2)
	{
		Operator=op;
		num1=n1;
		num2=n2;
		cal=NULL;
	}
	~OperationFactory()
	{
		if(cal)
			delete cal;
	}
	char Operator;
	Calculation * cal;
	double result;
	double n1;
	double n2;
    double  createCalculation()
	{
		switch(Operator)
		{
			case '+':
			{
				cal=new AddCalculation(n1,n2);
			}
			break;
			case '-':
			{
				cal=new Substract(n1,n2);
			}
			break;
			case '*':
			{
				cal=new Multiply(n1,n2);
			}
			break;
			case '/':
			{
				cal=new Divide(n1,n2);
				
			}
			break;
			default:
			break; 
		}
		result=cal->calculate();
	}
	
};
int main(int argc,char**argv)
{
	double n1,n2;
	while(cin>>n1>>n2);
	{

		OperationFactory opf(n1,'+',n2);
		cout<<opf.createCalculation()<<endl;
				
	}
	return 0;
}


 

 

 


原文链接:http://blog.csdn.net/ithzhang/article/details/7526498
加载中
返回顶部
顶部