大话设计模式源代码

（一）简单工厂模式

主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。

GOOD:适用于不同情况创建不同的类时

BUG：客户端必须要知道基类和工厂类，耦合性差

（工厂类与基类为关联关系）

例：

//基类
class COperation
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};
//加法
class AddOperation : public COperation
{
public:
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};
//减法
class SubOperation : public COperation
{
public:
	virtual double GetResult()
	{
		return m_nFirst-m_nSecond;
	}
};

//工厂类
class CCalculatorFactory
{
public:
	static COperation* Create(char cOperator);
};

COperation* CCalculatorFactory::Create(char cOperator)
{
	COperation *oper;
    //在C#中可以用反射来取消判断时用的switch，在C++中用什么呢？RTTI？？
	switch (cOperator)
	{
	case '+':
		oper=new AddOperation();
		break;
	case '-':
		oper=new SubOperation();
		break;
	default:
		oper=new AddOperation();
		break;
	}
	return oper;
}

客户端

int main()
{
	int a,b;
	cin>>a>>b;
	COperation * op=CCalculatorFactory::Create('-');
	op->m_nFirst=a;
	op->m_nSecond=b;
	cout<<op->GetResult()<<endl;
	return 0;
}

（二）策略模式

　　定义算法家族，分别封装起来，让它们之间可以互相替换，让算法变化，不会影响到用户

GOOD:适合类中的成员以方法为主，算法经常变动；简化了单元测试（因为每个算法都有自己的类，可以通过自己的接口单独测试。

　　策略模式和简单工厂基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应使用策略模式。

BUG:客户端要做出判断

 例

//策略基类
class COperation
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

//策略具体类—加法类
class AddOperation : public COperation
{
public:
	AddOperation(int a,int b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};

class Context
{
private:
	COperation* op;
public:
    Context(COperation* temp)
	{
        op=temp;
	}
	double GetResult()
	{
		return op->GetResult();
	}
};

//客户端
int main()
{
	int a,b;
    char c;
	cin>>a>>b;
　　cout<<”请输入运算符：;
    cin>>c;
    switch(c)
{
   case ‘+’:
	    Context *context=new Context(new AddOperation(a,b));
	cout<<context->GetResult()<<endl;
    break;
   default:
    break;
}
	return 0;
}

策略与工厂结合

GOOD:客户端只需访问Context类，而不用知道其它任何类信息，实现了低耦合。

在上例基础上，修改下面内容

class Context
{
private:
	COperation* op;
public:
    Context(char cType)
	{
        switch (cType)
        {
		case '+':
			op=new AddOperation(3,8);
			break;
		default:
			op=new AddOperation();
			break;
        }
	}
	double GetResult()
	{
		return op->GetResult();
	}
};
//客户端
int main()
{
	int a,b;
	cin>>a>>b;
	Context *test=new Context('+');
	cout<<test->GetResult()<<endl;
	return 0;
}

单一职责原则

就一个类而言，应该仅有一个引起它变化的原因。

　　如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其它职责能力。这种耦合会导制脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。

如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责。

开放――封闭原则

软件实体可以扩展，但是不可修改。即对于扩展是开放的，对于修改是封闭的。面对需求，对程序的改动是通过增加代码来完成的，而不是改动现有的代码。

当变化发生时，我们就创建抽象来隔离以后发生同类的变化。

开放――封闭原则是面向对象的核心所在。开发人员应该对程序中呈现出频繁变化的那部分做出抽象，拒绝对任何部分都刻意抽象及不成熟的抽象。

里氏代换原则

　　一个软件实体如果使用的是一个父类的话，那么一定适用其子类。而且它察觉不出父类对象和子类对象的区别。也就是说：在软件里面，把父类替换成子类，程序的行为没有变化。

子类型必须能够替换掉它们的父类型。

依赖倒转原则

抽象不应该依赖细节，细节应该依赖抽象。即针对接口编程，不要对实现编程。

　　高层模块不能依赖低层模块，两者都应依赖抽象。

　　依赖倒转原则是面向对象的标志，用哪种语言编写程序不重要，如果编写时考虑的是如何针对抽象编程而不是针对细节编程，即程序的所有依赖关系都终止于抽象类或接口。那就是面向对象设计，反之那就是过程化设计。

（三）装饰模式

动态地给一个对象添加一些额外的职责（不重要的功能，只是偶然一次要执行），就增加功能来说，装饰模式比生成子类更为灵活。建造过程不稳定，按正确的顺序串联起来进行控制。

GOOD:当你向旧的类中添加新代码时，一般是为了添加核心职责或主要行为。而当需要加入的仅仅是一些特定情况下才会执行的特定的功能时（简单点就是不是核心应用的功能），就会增加类的复杂度。装饰模式就是把要添加的附加功能分别放在单独的类中，并让这个类包含它要装饰的对象，当需要执行时，客户端就可以有选择地、按顺序地使用装饰功能包装对象。

例

#include <string>
#include <iostream>
using namespace std;
//人
class Person
{
private:
	string m_strName;
public:
	Person(string strName)
	{
		m_strName=strName;
	}
	Person(){}
	virtual void Show()
	{
		cout<<"装扮的是:"<<m_strName<<endl;
	}

};
//装饰类
class Finery :public Person
{
protected:
	Person* m_component;
public:
	void Decorate(Person* component)
	{
		m_component=component;
	}
	virtual void Show()
	{
		   m_component->Show();
	}
};
//T恤
class TShirts: public Finery
{
public:
	virtual void Show()
	{
		cout<<"T Shirts"<<endl;
		m_component->Show();
	}
};
//裤子
class BigTrouser :public  Finery
{
public:
	virtual void Show()
	{
		cout<<" Big Trouser"<<endl;
		m_component->Show();
	}
};

//客户端
int main()
{
	Person *p=new Person("小李");
	BigTrouser *bt=new BigTrouser();
	TShirts *ts=new TShirts();

	bt->Decorate(p);
	ts->Decorate(bt);
	ts->Show();
	return 0;
}

（四）代理模式

GOOD：远程代理，可以隐藏一个对象在不同地址空间的事实

　　　　　　　虚拟代理：通过代理来存放需要很长时间实例化的对象

　　　　　　　安全代理：用来控制真实对象的访问权限

　　　　　　　智能引用：当调用真实对象时，代理处理另外一些事

例：

#include <string>
#include <iostream>
using namespace std;
//定义接口
class Interface
{
public:
	virtual void Request()=0;
};
//真实类
class RealClass : public Interface
{
public:
	virtual void Request()
	{
		cout<<"真实的请求"<<endl;
	}
};
//代理类
class ProxyClass : public Interface
{
private:
	RealClass* m_realClass;
public:
	virtual void Request()
	{
	    m_realClass= new RealClass();
		m_realClass->Request();
		delete m_realClass;
	}
};

 客户端：

int main()
{
	ProxyClass* test=new ProxyClass();
	test->Request();
	return 0;
}

（五）工厂方法模式

GOOD：修正了简单工厂模式中不遵守开放－封闭原则。工厂方法模式把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可。

 例：

#include <string>
#include &