设计模式学习之工厂方法模式和原型模式

提出问题-分析问题-解决问题，这是一般写议论文的常规思路，正是通常文章采用这种方法来写的，所以学习一种理论，也是顺着这个思想来的，学习设计模式也不例外。在学任何一种模式前，一定要首先搞清楚这种模式产生的背景，即实际编码或修改维护代码中遇到的问题，然后分析出现的问题，是否违背了设计模式的原则或面向对象的思想，然后在引出解决这个问题用到的设计模式，最后对比总结，归纳出此种模式适用的场合及优缺点。
1.工厂方法模式

定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类

简单工厂模式VS工厂方法模式：简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。前面的简单工厂模式的计算器例子中，只需要把‘+’给工厂，工厂自动给出了相应的实例，客户端只要去做运算就可以了，不同的实例会实现不同的运算。但问题是，如果要增加一个功能，需要在工厂类的方法里加‘case’分支条件，这样不但对扩展开放了，对修改也开放了，违背了开放-封闭原则。既然这个工厂类与分支耦合，那么就对它下手，根据依赖倒转原则，把工厂类抽象出一个接口，这个接口只有一个方法，就是创建抽象产品的工厂方法，然后所有的生产具体类的工厂长就去实现这个接口，这样转成工厂方法模式后就不需要更改原有的工厂类了，只需要增加此功能的运算类和相应的工厂类就可以了，这样只有扩展的变化，没有修改的变化，就符合了开放-封有闭原则。

工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，只是把简单工厂的内部逻辑判断移到了客户端来进行，想要加功能，本来是改工厂类的，而现在是修改客户端。

实例：#include <string>
#include <iostream>
using namespace std;
//实例基类
class LeiFeng
{
public:
virtual void Sweep()
{
cout<<"雷锋扫地"<<endl;
}
};
//学雷锋的大学生，相当于 ConcreteProduct
class Student: public LeiFeng
{
public:
virtual void Sweep()
{
cout<<"大学生扫地"<<endl;
}
};
//学雷锋的志愿者，相当于 ConcreteProduct
class Volenter: public LeiFeng
{
public :
virtual void Sweep()
{
cout<<"志愿者扫地"<<endl;
}
};
//工场基类 Creator
class LeiFengFactory
{
public:
virtual LeiFeng* CreateLeiFeng()
{
return new LeiFeng();
}
};
//工场具体类
class StudentFactory : public LeiFengFactory
{
public :
virtual LeiFeng* CreateLeiFeng()
{
return new Student();
}
};
class VolenterFactory : public LeiFengFactory
{
public:
virtual LeiFeng* CreateLeiFeng()
{
return new Volenter();
}
};
//客户端
int main()
{
LeiFengFactory *sf=new LeiFengFactory();
LeiFeng *s=sf->CreateLeiFeng();
s->Sweep();
delete s;
delete sf;
return 0;
}

优点：工厂方法模式是简单工厂模式的进一步抽象和推广，由于使用了多态性，工厂方法模式保持了简单工厂模式封装对象创建过程的优点，而且遵循开放-封闭原则。工厂方法模式的缺点是由于每加一个产品，就需要加一个产品工厂的类，增加了额外的开发量。

2.原型模式

定义：从一个对象再创建另外一个可定制的对象，而无需知道任何创建的细节，并能提高创建的性能，说白了就是将一个对象完整地copy一份

实例：#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Prototype //抽象基类
{
private:
string m_strName;
public:
Prototype(string strName){ m_strName = strName; }
Prototype() { m_strName = " ";}
void Show()
{
cout<<m_strName<<endl;
}
virtual Prototype* Clone() = 0;
};
// class ConcretePrototype1
class ConcretePrototype1 : public Prototype
{
public:
ConcretePrototype1(string strName) : Prototype(strName){}
ConcretePrototype1(){}
virtual Prototype* Clone()
{
ConcretePrototype1 *p = new ConcretePrototype1();
*p = *this; //复制对象
return p;
}
};
// class ConcretePrototype2
class ConcretePrototype2 : public Prototype
{
public:
ConcretePrototype2(string strName) : Prototype(strName){}
ConcretePrototype2(){}
virtual Prototype* Clone()
{
ConcretePrototype2 *p = new ConcretePrototype2();
*p = *this; //复制对象
return p;
}
};
//客户端
int main()
{
ConcretePrototype1* test = new ConcretePrototype1("小王");
ConcretePrototype2* test2 = (ConcretePrototype2*)test->Clone();
test->Show();
test2->Show();
return 0;
}
应用场合：如果要对一个对象重复创建，那么每new一次，都需要执行一次构造函数，如果构造函数的执行时间很长，那么多次执行这个初始化就实在是太低效了。一般在初始化的信息不发生变化的情况下，克隆是最好的方法，这既隐藏了对象创建的细节，又对性能是大大的提高，不用重新初始化对象，而是动态地获得对象运行时的状态。