c++的设计模式系列分为以下几种：
//按照目的来分，有：
（1）创建型模式：处理对象的创建过程
（2）结构型模式：处理类或者对象的组合
（3）行为型模式：对怎样交互和分配职责的行为进行描述
一、创建型模式：（包含5种设计模式）：
工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式
二、结构型模式：（包含7种设计模式）
适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式
三、行为型模式：（包含11种设计模式）
责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式
//状态模式：允许一个对象在改变状态的同时改变它的行为，使得对象看起来像是修改了它的类
在实际开发中，我们经常会遇到这种情况；一个对象有多种状态，在每一个状态下，都会有不同的行为。那么在代码中我们经常是这样实现的。说明：（应答）青蛙寻求帮助：1、公主救了青蛙并吻了一口——青蛙变王子，返回darling；2、公主没有救青蛙——返回guaguagua
#include
using namespace std;
class Frog; //蛤蟆
class FrogState //状态
{
public:
virtual void Kiss() {}
virtual void Speak(Frog *frog) {}
};
class FrogSave:public FrogState
{
public:
virtual void Kiss()
{
cout<<"The frog changed into a handsome prince."<<endl;
}
virtual void Speak(Frog *frog)
{
cout<<"prince say:darling~"<<endl;
}
};
class FrogNSave:public FrogState
{
public:
virtual void Speak(Frog *frog)
{
cout<<"prince say:gua gua gua~"<FrogState::Kiss();
m_pFrogState->Speak(this);
}
}
void FrogNSave(FrogState *pFrogState)
{
m_pFrogState = pFrogState;
}
private:
FrogState *m_pFrogState;
};
int main()
{
Frog *frog = new Frog(new FrogSave());
Frog *pFrog = new Frog(0);
pFrog->FrogSave();
pFrog->FrogSave();
delete pFrog;
delete frog;
return 0;
}
using namespace std;
class Frog; //蛤蟆
class FrogState //状态
{
public:
virtual void Kiss() {}
virtual void Speak(Frog *frog) {}
};
class FrogSave:public FrogState
{
public:
virtual void Kiss()
{
cout<<"The frog changed into a handsome prince."<<endl;
}
virtual void Speak(Frog *frog)
{
cout<<"prince say:darling~"<<endl;
}
};
class FrogNSave:public FrogState
{
public:
virtual void Speak(Frog *frog)
{
cout<<"prince say:gua gua gua~"<FrogState::Kiss();
m_pFrogState->Speak(this);
}
}
void FrogNSave(FrogState *pFrogState)
{
m_pFrogState = pFrogState;
}
private:
FrogState *m_pFrogState;
};
int main()
{
Frog *frog = new Frog(new FrogSave());
Frog *pFrog = new Frog(0);
pFrog->FrogSave();
pFrog->FrogSave();
delete pFrog;
delete frog;
return 0;
}
1、它有两种使用情况：（1）一个对象的行为取决于它的状态, 并且它必须在运行时刻根据状态改变它的行为。（2）一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。
2、优点：（1）状态模式将与特定状态相关的行为局部化，并将不同状态的行为分割开来
（2）通过定义新的子类很容易改变它的状态
（3）通过把各种状态转移逻辑分不到的子类之间，来减少相互间的依赖
3、缺点：状态模式会增加系统类和对象的个数，较为混乱
本文的例子为第一种情况，以战争为例，假设一场战争需经历四个阶段：前期、中期、后期、结束。当战争处于不同的阶段，战争的行为是不一样的，也就说战争的行为取决于所处的阶段，而且随着时间的推进是动态变化的。
//责任链模式：在这个模式中，有一条链是由每一个对象对其下家的引用而连接起来的，请求在这条链上传递，一直到链上的某一个对象开始处理这个请求，这使得系统在不影响客户端的情况下动态的重新组织链和分配责任
说明：一个小孩先像妈妈要零花钱——要到break，没要到——像爸爸要零花钱——要到break，没要到——向奶奶要零花钱——要到break，没要到——向爷爷要零花钱——要到break，没要到——缺省函数收尾返回
#include
#include
using namespace std;
// 请求
class Request
{
public:
int P_money;//申请零花钱
};
// 家长
class Manager
{
public:
Manager(string temp)
{
name = temp;
}
void SetAnother(Manager* temp) { manager = temp; }
virtual void GetRequest(Request* request) = 0;//仅继承不实现
protected:
Manager* manager;
string name;
};
// 妈妈
class Mother : public Manager
{
public:
Mother(string strTemp) : Manager(strTemp) {}
virtual void GetRequest(Request* request);
};
void Mother::GetRequest(Request* request)
{
if (request->P_money==0 || request->P_money<=2)
{
cout << name << " 处理了请求:我不给，找你爸爸去！ " << endl;
}
else
{
manager->GetRequest(request);
}
}
// 爸爸
class Father : public Manager
{
public:
Father(string strTemp) : Manager(strTemp) {}
virtual void GetRequest(Request* request);
};
void Father::GetRequest(Request* request)
{
if (request->P_money>=0 && request->P_money<10)
{
cout << name << " 处理了请求:只给 " << request->P_money << endl;
}
else
{
manager->GetRequest(request);
}
}
// 奶奶
class Grandmother : public Manager
{
public:
Grandmother(string strTemp) : Manager(strTemp) {}
virtual void GetRequest(Request* request);
};
void Grandmother::GetRequest(Request* request)
{
if (request->P_money <= 50)
{
cout << name << " 处理了请求: 只给" << request->P_money << endl;
}else
{
manager->GetRequest(request);
}
}
//爷爷
class Grandfather: public Manager
{
public:
Grandfather(string name):Manager(name) {}
virtual void GetRequest(Request* request) ;
};
void Grandfather::GetRequest(Request* request)
{
if (request->P_money <= 100)
{
cout << name << " 处理了请求: 只给" << request->P_money << endl;
}else
{
manager->GetRequest(request);
}
}
int main(){
Manager* common = new Mother("妈妈");
Manager* major = new Father("爸爸");
Manager* nextmajor = new Grandmother("奶奶");
Grandfather* general = new Grandfather("爷爷");
common->SetAnother(major);
major->SetAnother(nextmajor);
nextmajor->SetAnother(general);
Request* rq = new Request();
rq->P_money = 1;
common->GetRequest(rq);
rq->P_money = 5;
common->GetRequest(rq);
rq->P_money = 43;
common->GetRequest(rq);
rq->P_money =84;
common->GetRequest(rq);
delete rq;
delete nextmajor;
delete major;
delete common;
delete general;
return 0;
}
#include
using namespace std;
// 请求
class Request
{
public:
int P_money;//申请零花钱
};
// 家长
class Manager
{
public:
Manager(string temp)
{
name = temp;
}
void SetAnother(Manager* temp) { manager = temp; }
virtual void GetRequest(Request* request) = 0;//仅继承不实现
protected:
Manager* manager;
string name;
};
// 妈妈
class Mother : public Manager
{
public:
Mother(string strTemp) : Manager(strTemp) {}
virtual void GetRequest(Request* request);
};
void Mother::GetRequest(Request* request)
{
if (request->P_money==0 || request->P_money<=2)
{
cout << name << " 处理了请求:我不给，找你爸爸去！ " << endl;
}
else
{
manager->GetRequest(request);
}
}
// 爸爸
class Father : public Manager
{
public:
Father(string strTemp) : Manager(strTemp) {}
virtual void GetRequest(Request* request);
};
void Father::GetRequest(Request* request)
{
if (request->P_money>=0 && request->P_money<10)
{
cout << name << " 处理了请求:只给 " << request->P_money << endl;
}
else
{
manager->GetRequest(request);
}
}
// 奶奶
class Grandmother : public Manager
{
public:
Grandmother(string strTemp) : Manager(strTemp) {}
virtual void GetRequest(Request* request);
};
void Grandmother::GetRequest(Request* request)
{
if (request->P_money <= 50)
{
cout << name << " 处理了请求: 只给" << request->P_money << endl;
}else
{
manager->GetRequest(request);
}
}
//爷爷
class Grandfather: public Manager
{
public:
Grandfather(string name):Manager(name) {}
virtual void GetRequest(Request* request) ;
};
void Grandfather::GetRequest(Request* request)
{
if (request->P_money <= 100)
{
cout << name << " 处理了请求: 只给" << request->P_money << endl;
}else
{
manager->GetRequest(request);
}
}
int main(){
Manager* common = new Mother("妈妈");
Manager* major = new Father("爸爸");
Manager* nextmajor = new Grandmother("奶奶");
Grandfather* general = new Grandfather("爷爷");
common->SetAnother(major);
major->SetAnother(nextmajor);
nextmajor->SetAnother(general);
Request* rq = new Request();
rq->P_money = 1;
common->GetRequest(rq);
rq->P_money = 5;
common->GetRequest(rq);
rq->P_money = 43;
common->GetRequest(rq);
rq->P_money =84;
common->GetRequest(rq);
delete rq;
delete nextmajor;
delete major;
delete common;
delete general;
return 0;
}1、责任链模式并不创建责任链，责任链的创建必须由系统的其他部分创建出来
2、优点：降低了请求的发送端和接收端之间的耦合，使得每个对象都有机会处理这个请求
（摘自十八道胡同博主的原创文章）
LCL_data原创于CSDN.NET【http://blog.csdn.Net/lcl_data/article/details/10248415】