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

学习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;
}