模板方法模式
GOOD：把不变的代码部分都转移到父类中。将可变的代码用virtual留到子类重写
#include<iostream>
#include<vector>
#include<string>
using namespacestd;
classAbstractClass
{
public:
void Show()
{
cout<<"我是"<<GetName()<<endl;
}
protected:
virtual string GetName()=0;
};
class Naruto :public AbstractClass
{
protected:
virtual string GetName()
{
return "火影史上最帅的六代目---一鸣惊人naruto";
}
};
class OnePice :public AbstractClass
{
protected:
virtual string GetName()
{
return "我是无恶不做的大海贼---路飞";
}
};
//client
int main()
{
Naruto* man = new Naruto();
man->Show();
OnePice* man2 = new OnePice();
man2->Show();
return 0;
}
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
外观模式
GOOD：为子系统的一组接口提供一个一致的界面。使用户使用起来更加方便。
#include<iostream>
#include<string>
using namespacestd;
class SubSysOne
{
public:
void MethodOne()
{
cout<<"方法一"<<endl;
}
};
class SubSysTwo
{
public:
void MethodTwo()
{
cout<<"方法二"<<endl;
}
};
classSubSysThree
{
public:
void MethodThree()
{
cout<<"方法三"<<endl;
}
};
//外观类
class Facade
{
private:
SubSysOne* sub1;
SubSysTwo* sub2;
SubSysThree* sub3;
public:
Facade()
{
sub1 = new SubSysOne();
sub2 = new SubSysTwo();
sub3 = new SubSysThree();
}
~Facade()
{
delete sub1;
delete sub2;
delete sub3;
}
voidFacadeMethod()
{
sub1->MethodOne();
sub2->MethodTwo();
sub3->MethodThree();
}
};
//client
int main()
{
Facade* test = new Facade();
test->FacadeMethod();
return 0;
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------建造者模式（生成器模式）
GOOD：在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用。#include<string>
#include<iostream>
#include<vector>
using namespacestd;
//终于的产品类
class Product
{
private:
vector<string> m_product;
public:
void Add(string strtemp)
{
m_product.push_back(strtemp);
}
void Show()
{
vector<string>::iteratorp=m_product.begin();
while (p!=m_product.end())
{
cout<<*p<<endl;
p++;
}
}
};
//建造者基类
class Builder
{
public:
virtual void BuilderA()=0;
virtual void BuilderB()=0;
virtual Product* GetResult()=0;
};
//第一种建造方式
classConcreteBuilder1 : public Builder
{
private:
Product* m_product;
public:
ConcreteBuilder1()
{
m_product=new Product();
}
virtual void BuilderA()
{
m_product->Add("one");
}
virtual void BuilderB()
{
m_product->Add("two");
}
virtual Product* GetResult()
{
return m_product;
}
};
//另外一种建造方式
classConcreteBuilder2 : public Builder
{
private:
Product * m_product;
public:
ConcreteBuilder2()
{
m_product=new Product();
}
virtual void BuilderA()
{
m_product->Add("A");
}
virtual void BuilderB()
{
m_product->Add("B");
}
virtual Product* GetResult()
{
return m_product;
}
};
//指挥者类
class Direct
{
public:
voidConstruct(Builder* temp)
{
temp->BuilderA();
temp->BuilderB();
}
};
//client
int main()
{
Direct *p=new Direct();
Builder* b1=new ConcreteBuilder1();
Builder* b2=new ConcreteBuilder2();
p->Construct(b1); //调用第一种方式
Product* pb1=b1->GetResult();
pb1->Show();
p->Construct(b2); //调用另外一种方式
Product * pb2=b2->GetResult();
pb2->Show();
return 0;
}
例二（事实上这个样例应该放在前面讲的）：
#include<string>
#include<iostream>
#include<vector>
using namespacestd;
class Person
{
public:
virtual void CreateHead()=0;
virtual void CreateHand()=0;
virtual void CreateBody()=0;
virtual void CreateFoot()=0;
};
class ThinPerson: public Person
{
public:
virtual void CreateHead()
{
cout<<"thinhead"<<endl;
}
virtual void CreateHand()
{
cout<<"thinhand"<<endl;
}
virtual void CreateBody()
{
cout<<"thinbody"<<endl;
}
virtual void CreateFoot()
{
cout<<"thinfoot"<<endl;
}
};
classThickPerson : public Person
{
public:
virtual void CreateHead()
{
cout<<"ThickPersonhead"<<endl;
}
virtual void CreateHand()
{
cout<<"ThickPersonhand"<<endl;
}
virtual void CreateBody()
{
cout<<"ThickPersonbody"<<endl;
}
virtual void CreateFoot()
{
cout<<"ThickPersonfoot"<<endl;
}
};
//指挥者类
class Direct
{
private:
Person* p;
public:
Direct(Person* temp) { p = temp;}
void Create()
{
p->CreateHead();
p->CreateBody();
p->CreateHand();
p->CreateFoot();
}
};
//client代码：
int main()
{
Person *p=new ThickPerson();
Direct *d= new Direct(p);
d->Create();
delete d;
delete p;
return 0;
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------观察者模式
GOOD：定义了一种一对多的关系。让多个观察对象（公司员工）同一时候监听一个主题对象（秘书），主题对象状态发生变化时，会通知全部的观察者，使它们可以更新自己。
#include <string>
#include <iostream>
#include <vector>
using namespace std;
class Secretary;
//看股票的同事类（观察对象，观察者）
class StockObserver
{
private:
stringname;
Secretary*sub;
public:
StockObserver(stringstrname,Secretary* strsub)
{
name=strname;
sub=strsub;
}
voidUpdate();
};
//秘书类（主题对象，通知者）
class Secretary
{
private:
vector<StockObserver>observers;
public:
stringaction;
voidAdd(StockObserver ob)
{
observers.push_back(ob);
}
voidNotify()
{
vector<StockObserver>::iterator p = observers.begin();
while(p!=observers.end())
{
(*p).Update();
p++;
}
}
};
void StockObserver::Update()
{
cout<<name<<":"<<sub->action<<",不要玩股票了。要開始工作了"<<endl;
}
//client
int main()
{
Secretary *p=new Secretary(); //创建通知者
//观察者
StockObserver*s1= new StockObserver("小李",p);
StockObserver*s2 = new StockObserver("小赵",p);
//增加通知队列
p->Add(*s1);
p->Add(*s2);
//事件
p->action="老板来了";
//通知
p->Notify();
return0;
}
#include <string>
#include<iostream>
#include<vector>
using namespacestd;
classSecretaryBase;
//抽象观察者
classCObserverBase
{
protected:
string name;
SecretaryBase* sub;
public:
CObserverBase(stringstrname,SecretaryBase* strsub)
{
name=strname;
sub=strsub;
}
virtual void Update()=0;
};
//详细的观察者，看股票的
classStockObserver : public CObserverBase
{
public:
StockObserver(stringstrname,SecretaryBase* strsub) : CObserverBase(strname,strsub)
{
}
virtual void Update();
};
//详细观察者，看NBA的
classNBAObserver : public CObserverBase
{
public:
NBAObserver(string strname,SecretaryBase*strsub) : CObserverBase(strname,strsub){}
virtual void Update();
};
//抽象通知者
classSecretaryBase
{
public:
string action;
vector<CObserverBase*> observers;
public:
virtual void Attach(CObserverBase*observer)=0;
virtual void Notify()=0;
};
//详细通知者
class Secretary:public SecretaryBase
{
public:
void Attach(CObserverBase* ob)
{
observers.push_back(ob);
}
void Notify()
{
vector<CObserverBase*>::iteratorp = observers.begin();
while (p!=observers.end())
{
(*p)->Update();
p++;
}
}
};
voidStockObserver::Update()
{
cout<<name<<":"<<sub->action<<",不要玩股票了。要開始工作了"<<endl;
}
voidNBAObserver::Update()
{
cout<<name<<":"<<sub->action<<",不要看NBA了，老板来了"<<endl;
}
client：
int main()
{
SecretaryBase *p=new Secretary(); //创建观察者
//被观察的对象
CObserverBase *s1= new NBAObserver("小李",p);
CObserverBase *s2 = newStockObserver("小赵",p);
//增加观察队列
p->Attach(s1);
p->Attach(s2);
//事件
p->action="老板来了";
//通知
p->Notify();
return 0;
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------