常用设计模式的作用

单例模式

保证一个类只生成唯一的实例对象，因为对象是唯一的，所以构造方法为私有，不可以通过new来创建。因此要提供一个静态的公开的方法，让外部类获取对象。
实现方式

工厂模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到其子类，用户可以根据工厂类去创建所需要的实例，无需了解这些对象是如何创建的
抽象工厂：当系统扩展需要添加新的产品，仅仅需要添加一个具体对象以及一个具体工厂对象，不需要对原有工厂对象进行任何修改；而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好

优点：工厂类包含必要的判断，可以根据外界给的信息，决定究竟该创建哪个具体的类的对象，用户使用时可以直接根据工厂类去创建所需要的实例，无需了解这些对象是如何创建的。
缺点：由于工厂类中集中了所有实例的创建逻辑，“高内聚”方面做得不好；当系统中的具体产品不断增多时，工厂类也要做相应修改，扩展性不太好。

工厂方法模式

定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中，核心工厂类不再负责产品的创建，核心类成为了一个抽象工厂的角色，仅负责具体工厂子类必须实现的接口。这样可以使得不修改具体工厂角色的情况下引进新产品。

优点：当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，符合“开放-封闭”原则，而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。

#include <iostream>
using namespace std;
 /*抽象产品类 TV(电视机类)*/ 
class TV
{
public:
  virtual void Show() = 0;
};
 /*具体产品类 HairTV(海尔电视机类)*/ 
class HairTV : public TV
{
public:
  void Show()
  {
    cout<< "I'm HairTV"<<endl;
  }
};
/*具体产品类 HisenseTV(海信电视机类)*/
class HisenseTV : public TV
{
public:
  void Show()
  {
    cout<< "I'm HisenseTV"<<endl;
  }
};
/*工厂类(电视机工厂类)*/  
class TVFactory
{
public:
  virtual TV *CreateTV() = 0;
};
 /*具体工厂类 HairTVFactory(海尔电视机工厂类)*/ 
class HairTVFactory : public TVFactory
{
public:
  TV *CreateTV()
  {
    return new HairTV ();
  }
};
 /*具体工厂类 HisenseTV(海信电视机工厂类)*/ 
class HisenseTVFactory : public TVFactory
{
public:
  TV *CreateTV()
  {
    return new HisenseTV ();
  }
};
  
int main(int argc , char *argv [])
{
  TVFactory *hairTVFactory = new HairTVFactory();
  TV *hairTV = hairTVFactory->CreateTV();
  hairTV->Show();
  
  TVFactory *hisenseTVFactory = new HisenseTVFactory();
  TV *hisenseTV = hisenseTVFactory->CreateTV();
  hisenseTV->Show();
  
  if (hairTVFactory!= NULL)
  {
    delete hairTVFactory;
    hairTVFactory = NULL;
  }
  
  if (hairTV != NULL)
  {
    delete hairTV;
    hairTV = NULL;
  }
  
  if (hisenseTVFactory != NULL)
  {
    delete hisenseTVFactory;
    hisenseTVFactory = NULL;
  }
  
  if (hisenseTV != NULL)
  {
    delete hisenseTV;
    hisenseTV = NULL;
  }
  return 0;
}
 

观察者模式

观察者模式是行为模式之一，作用是当被观察者对象的状态发生变化时，能够自动通知其他的观察者对象，自动刷新对象状态。
提供给关联对象一种同步通信的手段，使某个对象与依赖它的其他对象之间保持状态同步

//观察者
class Observer  
{
public:
	Observer() {}
	virtual ~Observer() {}
	virtual void Update() {} 
};
//博客
class Blog  
{
public:
	Blog() {}
	virtual ~Blog() {}
	void Attach(Observer *observer) {
		m_observers.push_back(observer); 
	}	 //添加观察者
	void Remove(Observer *observer) {
		m_observers.remove(observer); 
	}        //移除观察者
	void Notify() //通知观察者
	{
		list<Observer*>::iterator iter = m_observers.begin();
		for(; iter != m_observers.end(); iter++)
			(*iter)->Update();
	}
	virtual void SetStatus(string s) { m_status = s; } //设置状态
	virtual string GetStatus() { return m_status; }    //获得状态
private:
	list<Observer* > m_observers; //观察者链表
protected:
	string m_status; //状态
};

装饰模式

装饰器模式的定义是允许向一个现有的对象添加新的功能，同时又不改变其结构。就像是，我下个单，中间可能会有打折，可能会有运费，价格就会变动，所以我们就可以通过装饰器模式来实现。至于实现的话，其实也是主要靠继承与子类重写父类方法的原理来实现