标签：以c++ 设计模式的文本编辑 来自网络的集合 js文字边框闪亮 arc画圆
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<HEAD>
<style>textarea{width:500px;height:500px}table,td,tr{border:solid 1px black;}</style>
<script language="javascript">var secs = 20; var URL ="http://mzsts.host3v.com" ;
var now = new Date(); var year=now.getFullYear();var end = new Date(parseInt(year),6,1,0,0,0);
var i=0;var CC= new Array("#00F","#9F0","#603","#C66C","#FF3","66c","f33","f00");
function Load(){
if(parseInt(now.getMonth())>=6)end=new Date(parseInt(year)+1,6,1,0,0,0);
document.getElementById("pd").innerHTML="距离毕业仅有"+Math.floor((end-now)/86400000)+"天";
for(var i=secs;i>=0;i--){window.setTimeout(‘doUpdate(‘+i+‘)‘,(secs-i)*1000);}}
function doUpdate(num)
{if(secs>0){document.getElementById(‘ShowDiv‘).innerHTML = ‘将在‘+num+‘秒后自动跳转到主页‘ ;
if(num == 0){ window.location =URL; }}
}function timefun(){secs =-1;}
function fa(){ document.getElementById("aaa").src=‘http://www.anycodes.cn/zh/‘ }
function pp(){ if (i>CC.length-1){i=0}
tt.style.borderColor=CC[i];i=i+1; setTimeout("pp()",100);
}
pp();
</script>
</HEAD>
<body onload="Load();pp();" style="text-align:center;">
<center>
<table id="tt" border=3> <tr><td>
<canvas id="myCanvas" width="50px" height="50px" style="border: 1px solid red;"> </canvas>
<canvas id="myCanvas2" width="180px" height="50px" style="border: 1px solid red;"> </canvas>
</td> </tr>
</table>
<script type="text/javascript">
var canvas = document.getElementById("myCanvas");
if(canvas.getContext){
var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.strokeStyle = "blue";
var circle = { x : 10, y : 40, r : 10 };
ctx.arc(circle.x, circle.y, circle.r, -Math.PI*3/ 4, Math.PI / 2, false); ctx.stroke();
}
var canvas = document.getElementById("myCanvas");
if(canvas.getContext){
var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.strokeStyle = "blue";
var circle = { x : 25, y : 26, r : 10 };ctx.arc(circle.x, circle.y, circle.r, -Math.PI/2, Math.PI/4, true); ctx.stroke();
}
var canvas = document.getElementById("myCanvas");
if(canvas.getContext){
var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.strokeStyle = "red";
var circle = { x : 30, y : 35, r : 10 };
ctx.arc(circle.x, circle.y, circle.r, -Math.PI*3/ 4, Math.PI / 2, false); ctx.stroke();
}
var canvas = document.getElementById("myCanvas");
if(canvas.getContext){
var ctx = canvas.getContext("2d"); ctx.beginPath(); ctx.strokeStyle = "red";
var circle = { x :45, y : 23, r : 10 };ctx.arc(circle.x, circle.y, circle.r, -Math.PI/2, Math.PI/4, true); ctx.stroke();
}
var canvas = document.getElementById("myCanvas2");
if(canvas.getContext){
var ctx = canvas.getContext("2d");
ctx.font = "10px Courier New"; ctx.fillStyle = "blue";
ctx.fillText("文洲 的个人主页，彼岸", 10, 20);
ctx.fillText("http://mzsts.host3v.com", 10, 40);
}
</script>
<div id="ShowDiv"> </div>
</br>
<button onclick="timefun()">点击延时</button>
<button onclick="window.open(‘http://mzsts.host3v.com‘)">直接跳转</button>
<hr><p id="pd"></p><hr>
<p>总体来说设计模式分为三大类：
创建型模式，共五种：
原型模式。
单例模式、
建造者模式、
工厂方法模式、
抽象工厂模式、
结构型模式，共七种：
代理模式、
外观模式、
桥接模式、
组合模式、
享元模式、
适配器模式、
装饰器模式。
行为型模式，共十一种：
策略模式、
状态模式、
命令模式、
访问者模式、
备忘录模式、
责任链模式、
解释器模式、
观察者模式、
中介者模式、
迭代子模式、
模板方法模式、
其实还有两类：并发型模式和线程池模式。</p>
<table>
<tr><td> 【创建型模式】 </td><td>【优点】</td><td>【缺点】</td><td>【备注】</td></tr>
<tr><td><a href="#a">v原型模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#b">v单例模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#c">v建造者模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#d">v工厂模式</a></td><td>优点</td><td>缺点</td><td>工厂与产品 按要求生产</td></tr>
<tr><td><a href="#e">v抽象工厂</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td>【结构型模式】</td><td>【优点】</td><td>【缺点】</td><td>【备注】</td></tr>
<tr><td><a href="#f">代理模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#g">外观模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#h">v桥接模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#i">组合</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#j">v享元模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#k">适配器模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#l">v装饰器模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td>【行为型模式】</td><td>【优点】</td><td>【缺点】</td><td>【备注】</td></tr>
<tr><td><a href="#m">v策略模式</a></td><td> </td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#n">v状态模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#o">v命令模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#p">v访问者模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#q">v备忘录模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#r">v责任链模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#s">v解释器模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#t">v观察者模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#u">v中介者模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#v">V迭代子模式</a></td><td>优点</td><td>缺点</td><td>备注</td></tr>
<tr><td><a href="#w">模板方法模式</a></td><td>优点</td><td>缺点</td><td>简历模版，泡茶，代码重用性</td></tr>
</table>
<button onclick="fa()">打开编辑</button><iframe id="aaa"width="1300"height="500"></iframe>
<a href="http://blog.csdn.net/lcl_data/article/details/12117349">study</a><br>
<a href="http://www.cppblog.com/converse/category/2256.html">study</a><br>
<a href="http://blog.csdn.net/hudashi/article/category/1160910/1/">http://blog.csdn.net/</a><br>
<textarea id="a">
/**************
原型模式
**************/
#include <iostream>
using namespace std;
//Prototype 或带析构
class PT
{
public: PT(){};
virtual PT* clone() = 0; //纯虚克隆函数
};
class CPT:public PT
{
public:
CPT(){};
PT* clone(){return new CPT(*this);};//实现 虚克隆函数
private: CPT(const CPT&){cout<<"it is copy !\n";};
};
int main()
{
PT* p = new CPT(); //父指针指向 子类
PT* a = p->clone(); //父类一对象为子类克隆出来的对象
return 0;
}
</textarea><br>
<textarea id="b">
#include <iostream>
using namespace std;
class S{public: virtual void Show() = 0; };
class SA:public S{public:SA(){Show();} void Show() { cout<<"SA"<<endl;}};
class SB:public S{public:SB(){Show();}void Show() { cout<<"SB"<<endl; }};
class F{ public: virtual S* Create() = 0; };
class FA: public F{public:FA(){Create();}SA* Create(){return new SA();} };
class FB: public F{public:FB(){Create();}SB* Create(){return new SB(); } };
int main()
{
FA fa;
FB fb;
return 0;
}
/**************
【S】
【SA】 【SB】
【F】
【FA】 【FB】
**************/
</textarea><br>
<textarea id="c">
#include <iostream>
using namespace std;
class single1
{
public:
static single1& getInstance()
{
static single1 instance;
return instance;
}
int helloSingle() {return 1;}
private:
single1(){};
single1(const single1&);
single1& operator=(const single1&);
};
class single2
{
public:
static single2* getInstance()
{
return mInstance;
}
int helloSingle() {return 1;}
private:
static single2* mInstance;
private:
single2(){};
single2(const single2&);
single2& operator=(const single2&);
};
single2* single2::mInstance = new single2;
int main()
{
// single2 s2=new single2();
return 0;
}
/*
剑指offer开篇有相关
单例模式
该类不能被复制。
该类不能被公开的创造。
只有当需要改类的时候去构造（即为懒汉模式） S1
在程序开始之前我就先构造好，你到时候直接用就可（即为饿汉模式） S2
*/
</textarea><br>
<textarea id="d">
#include <iostream>
using namespace std;
enum cp {cp1, cp2};
class S { public: virtual void Show() = 0; };
class SA: public S { public: void Show(){ cout<<"SA"<<endl; } };
class SB: public S { public: void Show(){ cout<<"SB"<<endl; } };
class Factory
{
public:
S* create(enum cp cp12)
{
if(cp12 == cp1) {SA*sa= new SA(); sa->Show();}
else if(cp12 == cp2) {SB*sb= new SB(); sb->Show();}
else { cout<<"error"; return NULL; }
}
};
int main()
{
Factory *f=new Factory();
f->create(cp1);
return 0;
}
/**************
【S】
【SA】 【SB】
【Factory】
**************/
</textarea><br>
<textarea id="e">
#include <iostream>
using namespace std;
class S { public: virtual void Show() = 0; };
class SA: public S
{public: SA(){Show();}void Show() { cout<<"SA"<<endl; } };
class SB: public S
{public: SB(){Show();}void Show() { cout<<"SB"<<endl; } };
class M
{ public: virtual void Show() = 0; };
class MA : public M
{ public: MA(){Show();} void Show() { cout<<"MA"<<endl; } };
class MB : public M
{ public: MB(){Show();} void Show() { cout<<"MB"<<endl; } };
class F {public:virtual S*CreateS()=0; virtual M*CreateM()=0; };
class FA :public F
{
public: FA(){CreateS();CreateM();}
S* CreateS() { return new SA(); }
M* CreateM() { return new MA(); }
};
class FB :public F
{
public: FB(){CreateS();CreateM();}
S* CreateS() { return new SB(); }
M* CreateM() { return new MB(); }
};
int main()
{
FA fa;
FB fb;
return 0;
}
/************************
【S】 【M】
【SA】【SB】|【MA】【MB】
\ X /
【FA】【FB】
【F】
***********************/
</textarea><br>
<a href="http://blog.csdn.net/cabinriver/article/details/8895372/">study</a><br>
<a href="http://blog.csdn.net/lbqbraveheart/article/details/7185561/">代理模式</a><br>
<textarea id="f">
#include <iostream>
using namespace std;
class subject
{
public:
subject(){}
virtual ~subject(){}
public:
virtual void Request() = 0;
};
//定义真正的实体
class realsubject :public subject
{
public:
realsubject();
virtual ~realsubject();
public:
virtual void Request();
};
//定义代理类,含有一个指向realsubject的对象的指针
class proxy :public subject
{
public:
proxy();
virtual ~proxy();
public:
virtual void Request();
private:
realsubject* pRealsubject;
};
realsubject::realsubject()
{
cout<<"constructing a realsubject"<<endl;
}
realsubject::~realsubject()
{
cout<<"distory the realsubject"<<endl;
}
void realsubject::Request()
{
cout<<"request by realsubject"<<endl;
}
proxy::proxy()
{
pRealsubject = NULL;
cout<<"constructing a proxy"<<endl;
}
proxy::~proxy()
{
delete pRealsubject;
pRealsubject = NULL;
cout<<"distory the proxy"<<endl;
}
void proxy::Request()
{
//需要使用realsubject的时候去初始化一下
if(NULL == pRealsubject)
{
cout<<"request by proxy"<<endl;
pRealsubject = new realsubject();
}
pRealsubject->Request();
}
int main()
{
subject *pProxy = new proxy();
pProxy->Request();
delete pProxy;
pProxy = NULL;
return 0;
}
</textarea><br>
<textarea id="g">
http://blog.csdn.net/lcl_data/article/details/8841779/
#include<iostream>
using namespace std;
class Scanner
{
public:
void Scan() { cout<<"词法分析"<<endl; }
};
class Parser
{
public:
void Parse() { cout<<"语法分析"<<endl; }
};
class GenMidCode
{
public:
void GenCode() { cout<<"产生中间代码"<<endl; }
};
class GenMachineCode
{
public:
void GenCode() { cout<<"产生机器码"<<endl;}
};
class Compiler //高层接口 Fecade
{
public:
void Run()
{
Scanner scanner;
Parser parser;
GenMidCode genMidCode;
GenMachineCode genMacCode;
scanner.Scan();
parser.Parse();
genMidCode.GenCode();
genMacCode.GenCode();
}
};
int main()
{ Compiler compiler; //client
compiler.Run();
return 0;
}
</textarea><br>
<textarea>
http://blog.csdn.net/gotosola/article/details/7673610
#include <iostream>
using namespace std;
class SubSystemOne
{
public:
void MethorOne() { cout<<"子系统方法一"<<endl; }
};
class SubSystemTwo
{
public:
void MethorTwo() { cout<<"子系统方法二"<<endl; }
};
class SubSystemThree
{
public:
void MethorThree() { cout<<"子系统方法三"<<endl; }
};
class SubSystemFour
{
public:
void MethorFour() { cout<<"子系统方法四"<<endl; }
};
class Facade
{ /* 外观类，接口 */
SubSystemOne *one;
SubSystemTwo *two;
SubSystemThree *three;
SubSystemFour *four;
public: Facade()
{
one = new SubSystemOne();
two = new SubSystemTwo();
three = new SubSystemThree();
four = new SubSystemFour();
}
void MethorA()
{
cout<<"方法组A()"<<endl;
one->MethorOne();
two->MethorTwo();
}
void MethorB()
{
cout<<"方法组B()"<<endl;
three->MethorThree();
four->MethorFour();
}
};
void main()
{ //与接口Facade交互就可以访问四个子类系统
Facade facade;
facade.MethorA();
facade.MethorB();
}
</textarea>
<textarea id="h">
//http://www.2cto.com/kf/201603/492612.html
//桥接模式
#include <iostream>
using namespace std;
using std::string;
class OperatinSystem {
public:
OperatinSystem (){};
virtual ~OperatinSystem (){};
virtual void doPlay() = 0;
};
class Linux : public OperatinSystem {
public:
Linux (){};
virtual ~Linux(){};
virtual void doPlay(){
std::cout << " Linux" << std::endl;
}
};
class Unix : public OperatinSystem {
public:
Unix(){};
virtual ~Unix(){};
virtual void doPlay(){
std::cout << " Unix" << std::endl;
}
};
class Windows : public OperatinSystem {
public:
Windows (){};
virtual ~Windows(){};
virtual void doPlay(){
std::cout << " Windows" << std::endl;
}
};
class Player {
protected:
OperatinSystem *OS;
public:
Player (): OS(NULL){};
virtual void setOS(OperatinSystem *os){OS = os;}
virtual ~Player (){};
virtual void play() = 0;
};
class MP3Player : public Player{
public:
MP3Player(){};
virtual ~MP3Player(){};
virtual void play(){
std::cout << "Play MP3 under ";
OS->doPlay();
}
};
class WAVPlayer : public Player{
public:
WAVPlayer(){};
virtual ~WAVPlayer(){};
virtual void play(){
std::cout << "Play WAV under ";
OS->doPlay();
}
};
class WMAPlayer : public Player{
public:
WMAPlayer(){};
virtual ~WMAPlayer(){};
virtual void play(){
std::cout << "Play WMA under ";
OS->doPlay();
}
};
int main(void)
{
Player *mp3Player = new MP3Player;
mp3Player->setOS(new Linux);
mp3Player->play();
mp3Player->setOS(new Windows);
mp3Player->play();
mp3Player->setOS(new Unix);
mp3Player->play();
Player *wmalayer = new WMAPlayer;
wmalayer->setOS(new Linux);
wmalayer->play();
wmalayer->setOS(new Windows);
wmalayer->play();
wmalayer->setOS(new Unix);
wmalayer->play();
Player *wavPlayer = new WAVPlayer;
wavPlayer->setOS(new Linux);
wavPlayer->play();
wavPlayer->setOS(new Windows);
wavPlayer->play();
wavPlayer->setOS(new Unix);
wavPlayer->play();
}
</textarea><br>
<a href="http://blog.csdn.net/mafuli007/article/details/8177091/">study</a><br>
<textarea id="i">
#include <iostream>
#include <string>
#include <list>
using namespace std;
class Component
{
protected:
string name;
public:
Component(string name)
:name(name)
{ }
virtual void AddComponent(Component *component) { }
virtual void RemoveComponent(Component *component) { }
virtual void GetChild(int depth) { }
};
class Leaf: public Component
{
public:
Leaf(string name)
:Component(name)
{ }
void AddComponent(Component *component)
{
cout<<"Leaf can‘t add component"<<endl;
}
void RemoveComponent(Component *component)
{
cout<<"Leaf can‘t remove component"<<endl;
}
void GetChild(int depth)
{
string _tmpstring(depth, ‘-‘);
cout<<_tmpstring<<name<<endl;
}
};
class Composite:public Component
{
private:
list<Component*> _componets;
public:
Composite(string name)
:Component(name)
{ }
void AddComponent(Component *component)
{
_componets.push_back(component);
}
void RemoveComponent(Component *component)
{
_componets.remove(component);
}
void GetChild(int depth)
{
string tmpstring (depth, ‘-‘);
cout<<tmpstring<<name<<endl;
list<Component*>::iterator iter = _componets.begin();
for(; iter != _componets.end(); iter++)
{
(*iter)->GetChild(depth + 2);
}
}
};
int main()
{
Composite *root = new Composite("root");
Leaf *leaf1 = new Leaf("leaf1");
Leaf *leaf2 = new Leaf("leaf2");
root->AddComponent(leaf1);
root->AddComponent(leaf2);
Composite *lay2 = new Composite("layer2");
Leaf *leaf4 = new Leaf("leaf4");
lay2->AddComponent(leaf4);
Composite *lay1 = new Composite("layer1");
Leaf *leaf3 = new Leaf("leaf3");
lay1->AddComponent(leaf3);
lay1->AddComponent(lay2);
root->AddComponent(lay1);
root->GetChild(1);
cout<<endl;
lay1->GetChild(1);
cout<<endl;
lay2->GetChild(1);
delete root;
delete lay1;
delete lay2;
delete leaf1;
delete leaf2;
delete leaf3;
delete leaf4;
return 0;
}
/**************
组合模式
**************/
</textarea><br>
<textarea id="k">
//http://blog.csdn.net/lcl_data/article/details/8780140/
//注意 这里有3篇
#include<iostream>
using namespace std;
// "ITarget"
class Target
{
public:
// Methods
virtual void Request(){};
};
// "Adaptee"
class Adaptee
{
public:
// Methods
void SpecificRequest()
{
cout<<"Called SpecificRequest()"<<endl;
}
};
// "Adapter"
class Adapter : public Adaptee, public Target
{
public:
// Implements ITarget interface
void Request()
{
// Possibly do some data manipulation
// and then call SpecificRequest
this->SpecificRequest();
}
};
int main()
{
// Create adapter and place a request
Target *t = new Adapter();
t->Request();
return 0;
}
</textarea><br>
<textarea id="l">
#include <iostream>
using namespace std ;
class Component {/*统一接口*/ public : virtual void Operation ( ) = 0 ;} ;
class ConcreteComponent : public Component
{
public :
void Operation ( ) { cout << "I am no decoratored ConcreteComponent" << endl ;}
} ;
class Decorator : public Component
{
public : Decorator ( Component * pComponent ) : ComObj ( pComponent ) { }
void Operation ( )
{
if (ComObj != NULL )
{ ComObj-> Operation ( ) ; }
}
protected :
Component * ComObj ;
} ;
class DA : public Decorator
{
public : DA ( Component * pDecorator ) : Decorator ( pDecorator ) { }
void Operation ( )
{
AddedBehavior ( ) ; ComObj -> Operation ( ) ;
}
void AddedBehavior ( )
{
cout << "This is added behavior A. A版装饰行为" << endl ;
}
} ;
class DB : public Decorator
{
public : DB ( Component * pDecorator ) : Decorator ( pDecorator ) { }
void Operation ( )
{
AddedBehavior ( ) ; ComObj -> Operation ( ) ;
}
void AddedBehavior ( )
{
cout << "This is added behavior B. B版装饰行为" << endl ;
}
} ;
int main ( )
{
Component * pComponentObj = new ConcreteComponent ( ) ;
Decorator * pDecoratorAOjb = new DA ( pComponentObj ) ;
pDecoratorAOjb -> Operation ( ) ;
cout << "=============================================" << endl ;
Decorator * pDecoratorBOjb = new DB ( pComponentObj ) ;
pDecoratorBOjb -> Operation ( ) ;
cout << "=============================================" << endl ;
Decorator * pDecoratorBAOjb = new DB ( pDecoratorAOjb ) ;
pDecoratorBAOjb -> Operation ( ) ;
cout << "=============================================" << endl ;
Decorator * pDecoratorABOjb = new DA ( pDecoratorBOjb ) ;
pDecoratorABOjb -> Operation ( ) ;
cout << "=============================================" << endl ;
//以下为 对逆序删除对象
delete pDecoratorABOjb ; pDecoratorABOjb = NULL ;
delete pDecoratorBAOjb ; pDecoratorBAOjb = NULL ;
delete pDecoratorBOjb ; pDecoratorBOjb = NULL ;
delete pDecoratorAOjb ; pDecoratorAOjb = NULL ;
delete pComponentObj ; pComponentObj = NULL ;
return 0;
}
/**************
装饰者模式 装饰蛋糕 装饰行为
http://www.tuicool.com/articles/vARf2uq/
[Component组件]
【ConcreteComponent混凝土构件】 [Decorator装饰者]
CC [ConcreteDecoratorA具体装饰者A][ConcreteDecoratorB具体装饰者B]
DA DB
IT发展的时代，单词的理解还是重要的，上面的翻译来自百度翻译。有道ConcreteComponent翻译不出
**************/
</textarea> <br>
<a href="http://www.cnblogs.com/tiandsp/archive/2012/06/30/2571314.html">策略模式</a><br>
<textarea id="m">
/*********
策略模式
*********/
#include <iostream>
#include <string>
using namespace std;
class math
{
public:
math(){}
virtual ~math(){}
virtual void add()=0;
};
class ADD1 : public math
{
public:
ADD1(){}
virtual ~ADD1(){}
void add()
{
cout<<"the first type of add"<<endl;
}
};
class ADD2 : public math
{
public:
ADD2(){}
virtual ~ADD2(){}
void add()
{
cout<<"the second type of add"<<endl;
}
};
class calculate
{
public:
calculate(){}
~calculate(){}
void set_alg(math *p)
{
p_math=p;
}
void operation()
{
p_math->add();
}
protected:
math *p_math;
};
int main()
{
calculate *p_cal=new calculate;
math *p_add1=new ADD1;
math *p_add2=new ADD2;
p_cal->set_alg(p_add1);
p_cal->operation();
p_cal->set_alg(p_add2);
p_cal->operation();
delete p_add2;
delete p_add1;
delete p_cal;
//system("pause");
return 0;
}
/**************
**************/
</textarea><br>
<textarea id="n">
#include <iostream>
using namespace std;
class Worker;
class State{ public: virtual void doing(Worker* w){} };
class WorkingState: public State { public: void doing(Worker* worker); };
class SleepingState: public State { public: void doing(Worker* worker); };
class OtherState : public State { public: void doing(Worker* worker); };
class Worker
{
public: Worker() { state = new WorkingState(); }
void setState(State* stat) { state = stat; }
double getHour() { return hour;}
void setHour(double hou) { cout << "time is "<<hou << endl; hour = hou; }
void requestDoing() { state->doing(this); }
private:
State* state;
double hour;
};
//各个状态doing方法的实现 各自状态都做什么
void WorkingState::doing(Worker* worker)
{
if(worker->getHour() > 8 && worker->getHour() < 16) cout << "WorkingState!" << endl;
/* [8,16]白天工作 */
else
{
worker->setState(new OtherState()); worker->requestDoing();
}
}
void SleepingState::doing(Worker* worker)
{
if(worker->getHour() >= 21 || worker->getHour() < 5) cout << "SleepingState!" << endl;
/*[21,24]U[0,5] 晚上休息*/
else
{
worker->setState(new OtherState()); worker->requestDoing();
}
}
void OtherState::doing(Worker* worker)
{
if((worker->getHour() >= 5 && worker->getHour() < 8) || (worker->getHour() >= 16 && worker->getHour() < 21))
cout << "others!" << endl;
/* [5,8]U[16,21] 在路上其他事情 */
else if(worker->getHour() >= 21 || worker->getHour() < 5)
{
worker->setState(new SleepingState()); worker->requestDoing();
}
else
{
worker->setState(new WorkingState()); worker->requestDoing();
}
}
//客户代码
int main()
{
Worker* pWorker = new Worker();
pWorker->setHour(24); pWorker->requestDoing();
pWorker->setHour(12); pWorker->requestDoing();
delete pWorker;
return 0;
}
/**************
【State】
【S1】【S2】【S3】
【Worker】
**************/
</textarea><br>
<textarea id="o">
// /http://blog.csdn.net/lcl_data/article/details/9080909//
#include <iostream>
#include <vector>
using namespace std;
class RoastCook
{
public: // 烤肉师傅
void MakeMutton() { cout << "烤羊肉" << endl; }
void MakeChickenWing() { cout << "烤鸡翅膀" << endl; }
};
class Command
{ // 抽象命令类
public: Command(RoastCook* temp) { receiver = temp; }
virtual void ExecuteCmd() = 0;
protected: RoastCook* receiver;
};
class MakeMuttonCmd : public Command
{
public: // 烤羊肉命令
MakeMuttonCmd(RoastCook* temp) : Command(temp) {}
virtual void ExecuteCmd() { receiver->MakeMutton(); }
};
class MakeChickenWingCmd : public Command
{
public: // 烤鸡翅膀命令
MakeChickenWingCmd(RoastCook* temp) : Command(temp) {}
virtual void ExecuteCmd() { receiver->MakeChickenWing(); }
};
// 服务员类
class Waiter
{
public:
void SetCmd(Command* temp)
{
m_commandList.push_back(temp); cout << "增加订单" << endl;
}
void Notify()// 通知执行
{
vector<Command*>::iterator it;
for (it=m_commandList.begin(); it!=m_commandList.end(); ++it)
{
(*it)->ExecuteCmd();//遍历通知 菜单
}
}
protected:
vector<Command*> m_commandList; //服务员手里记录菜单的容器本本
};
int main()
{
//烤肉师傅
RoastCook* cook = new RoastCook();
//服务员
Waiter* girl = new Waiter();
//顾客点的菜单
Command* cmd1 = new MakeMuttonCmd(cook);
Command* cmd2 = new MakeChickenWingCmd(cook);
//服务员记录菜单
girl->SetCmd(cmd1);
girl->SetCmd(cmd2);
//服务员通知烤肉师傅
girl->Notify();
return 0;
}
/**************
【厨师】
【服务员】
【顾客菜单】即发起两条命令
**************/
</textarea><br>
<a href="http://www.cnblogs.com/tiandsp/archive/2012/06/28/2568698.html">备忘录模式</a><br>
<textarea id="q">
#include <iostream>
#include <string>
#include <vector>
#include <iomanip>
using namespace std;
class info
{
public:
info():pc(0){}
~info(){}
void input(string name,int age,int salary)
{
_name.push_back(name);
_age.push_back(age);
_salary.push_back(salary);
pc++;
}
void show()
{
for (int i=0;i<pc;i++)
{
cout<<"name :"<<_name[i]<<setw(10);
cout<<"age :"<<_age[i]<<setw(10);
cout<<"salary:"<<_salary[i]<<endl;
}
}
info* operator=(info* p)
{
info* temp;
temp->_name=p->_name;
temp->_age=p->_age;
temp->_salary=p->_salary;
temp->pc=p->pc;
return temp;
}
private:
int pc;
vector<string> _name;
vector<int> _age;
vector<int> _salary;
};
class Memorandum
{
public:
Memorandum(){}
~Memorandum(){}
void Save(info p)
{
_wh.push_back(p);
}
info Load()
{
vector<info>::reverse_iterator rit;
rit=_wh.rbegin();
return *rit;
}
private:
vector<info> _wh;
};
int main()
{
Memorandum *p_wh=new Memorandum;
info p_info;
p_info.input("zhangsan",20,4000);
p_wh->Save(p_info);
p_info.show();
cout<<endl;
p_info.input("lisi",22,5000);
p_info.input("wangwu",23,6000);
p_info.show();
cout<<endl;
p_info=p_wh->Load();
p_info.show();
delete p_wh;
//system("pause");
return 0;
}
/*
http://www.cnblogs.com/tiandsp/archive/2012/06/28/2568698.html
备忘录模式
*/
/**************
**************/
</textarea><br>
<a href="http://www.tuicool.com/articles/vARf2uq/">study</a><br>
<textarea id="r">
/*
责任链模式 c++
*/
#include <iostream>
using namespace std;
class Manager
{
protected:
Manager *m_manager;
string m_name;
public:
Manager(Manager *manager, string name):m_manager(manager), m_name(name){}
virtual void DealWithRequest(string name, int num) {}
};
//经理
class CommonManager: public Manager
{
public:
CommonManager(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num)
{
if(num < 500) //经理职权之内
{
cout<<"经理"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
else
{
cout<<"经理"<<m_name<<"无法处理，交由总监处理"<<endl;
m_manager->DealWithRequest(name, num);
}
}
};
//总监
class Majordomo: public Manager
{
public:
Majordomo(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num)
{
if(num < 1000) //总监职权之内
{
cout<<"总监"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
else
{
cout<<"总监"<<m_name<<"无法处理，交由总经理处理"<<endl;
m_manager->DealWithRequest(name, num);
}
}
};
//总经理
class GeneralManager: public Manager
{
public:
GeneralManager(Manager *manager, string name):Manager(manager,name) {}
void DealWithRequest(string name, int num) //总经理可以处理所有请求
{
cout<<"总经理"<<m_name<<"批准"<<name<<"加薪"<<num<<"元"<<endl<<endl;
}
};
int main()
{
Manager *general = new GeneralManager(NULL, "A"); //设置上级，总经理没有上级
Manager *majordomo = new Majordomo(general, "B"); //设置上级
Manager *common = new CommonManager(majordomo, "C"); //设置上级
common->DealWithRequest("D",300); //员工D要求加薪
common->DealWithRequest("E", 600);
common->DealWithRequest("F", 1000);
delete common; delete majordomo; delete general;
return 0;
}
/**************
**************/
</textarea><br>
<a href="http://blog.csdn.net/lcl_data/article/details/9259905">解释器模式</a><br>
<textarea id="s">
/*
解释器模式
*/
#include <iostream>
#include <map>
#include <string>
using namespace std;
class Context
{
private:
map<string, int> valueMap;
public:
void addValue(string key,int value)
{
valueMap.insert(std::pair<string,int>(key,value));
}
int getValue(string key)
{
return valueMap[key];
}
};
class AbstractExpression
{
public :
virtual int interpreter(Context context) = 0;
};
class AddNonterminalExpression : public AbstractExpression
{
private :
AbstractExpression *left;
AbstractExpression *right;
public:
AddNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
{
this->left = left;
this->right = right;
}
int interpreter(Context context)
{
return this->left->interpreter(context) + this->right->interpreter(context);
}
};
class SubtractNonterminalExpression : public AbstractExpression
{
private :
AbstractExpression *left;
AbstractExpression *right;
public:
SubtractNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
{
this->left = left;
this->right = right;
}
int interpreter(Context context)
{
return this->left->interpreter(context) - this->right->interpreter(context);
}
};
class TerminalExpression : public AbstractExpression
{
private :
int i;
public :
TerminalExpression(int i)
{
this->i = i;
}
int interpreter(Context context)
{
return this->i;
}
};
int main(){
//a-b+c
Context context;
context.addValue("a", 7);
context.addValue("b", 8);
context.addValue("c", 2);
SubtractNonterminalExpression *subtractValue = new SubtractNonterminalExpression(new TerminalExpression(
context.getValue("a")), new TerminalExpression(context.getValue("b")));
AddNonterminalExpression *addValue = new AddNonterminalExpression(subtractValue, new TerminalExpression(
context.getValue("c")));
cout<< addValue->interpreter(context);
return 0;
}
/**************
**************/
</textarea><br>
<a href="http://blog.csdn.net/wuzhekai1985/article/details/6674984/">study</a><br>
<textarea id="t">
/****
观察者模式
***/
#include <list>
#include <iostream>
using namespace std;
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; //状态
};
class BlogCSDN : public Blog
{
private:
string m_name; //博主名称
public:
BlogCSDN(string name): m_name(name) {}
~BlogCSDN() {}
void SetStatus(string s) { m_status = "CSDN通知 : " + m_name + s; } //具体设置状态信息
string GetStatus() { return m_status; }
};
//具体观察者
class ObserverBlog : public Observer
{
private:
string m_name; //观察者名称
Blog *m_blog; //观察的博客，当然以链表形式更好，就可以观察多个博客
public:
ObserverBlog(string name,Blog *blog): m_name(name), m_blog(blog) {}
~ObserverBlog() {}
void Update() //获得更新状态
{
string status = m_blog->GetStatus();
cout<<m_name<<"-------"<<status<<endl;
}
};
int main()
{
Blog *blog = new BlogCSDN("wuzhekai1985");
Observer *observer1 = new ObserverBlog("tutupig", blog);
blog->Attach(observer1);
blog->SetStatus("发表设计模式C++实现（15）——观察者模式");
blog->Notify();
delete blog; delete observer1;
return 0;
}
/**************
**************/
</textarea><br>
<a href="http://blog.csdn.net/wuzhekai1985/article/details/6670298/">享元模式</a><br>
<textarea id="j">
/*
享元模式
*/
#include <iostream>
#include<vector>
using namespace std;
enum PieceColor {BLACK, WHITE}; /* 棋子颜色 */
struct PiecePos /* 棋子位置 */
{
int x;
int y;
PiecePos(int a, int b): x(a), y(b) {}
};
class Piece /* 棋子定义 */
{
protected:
PieceColor m_color; /*颜色 */
PiecePos m_pos; /*位置 */
public:
Piece(PieceColor color, PiecePos pos): m_color(color), m_pos(pos) {}
~Piece() {}
virtual void Draw() {}
};
class BlackPiece: public Piece
{
public: BlackPiece(PieceColor color, PiecePos pos): Piece(color, pos) {}
~BlackPiece() {}
void Draw() { cout<<"绘制一颗黑棋"<<endl;}
};
class WhitePiece: public Piece
{
public: WhitePiece(PieceColor color, PiecePos pos): Piece(color, pos) {}
~WhitePiece() {}
void Draw() { cout<<"绘制一颗白棋"<<endl;}
};
class PieceBoard
{
private:
vector<Piece*> m_vecPiece; //棋盘上已有的棋子
string m_blackName; //黑方名称
string m_whiteName; //白方名称
public:
PieceBoard(string black, string white): m_blackName(black), m_whiteName(white){}
~PieceBoard() { Clear(); }
void SetPiece(PieceColor color, PiecePos pos) //一步棋，在棋盘上放一颗棋子
{
Piece * piece = NULL;
if(color == BLACK) //黑方下的
{
piece = new BlackPiece(color, pos); //获取一颗黑棋
cout<<m_blackName<<"在位置("<<pos.x<<‘,‘<<pos.y<<")";
piece->Draw(); //在棋盘上绘制出棋子
}
else
{
piece = new WhitePiece(color, pos);
cout<<m_whiteName<<"在位置("<<pos.x<<‘,‘<<pos.y<<")";
piece->Draw();
}
m_vecPiece.push_back(piece); //加入容器中
}
void Clear() //释放内存
{
int size = m_vecPiece.size();
for(int i = 0; i < size; i++)
delete m_vecPiece[i];
}
};
int main()
{
PieceBoard pieceBoard("A","B");
pieceBoard.SetPiece(BLACK, PiecePos(4, 4));
pieceBoard.SetPiece(WHITE, PiecePos(4, 16));
pieceBoard.SetPiece(BLACK, PiecePos(16, 4));
pieceBoard.SetPiece(WHITE, PiecePos(16, 16));
}
/**************
**************/
</textarea><br>
<textarea>
/**************
**************/
</textarea><br>
<a href="http://blog.csdn.net/wuzhekai1985/article/details/6673603">中介模式</a></br>
<textarea id="u">
#include <iostream>
using namespace std;
class Mediator;
//抽象人
class Person
{
protected:
Mediator *m_mediator; //中介
public:
virtual void SetMediator(Mediator *mediator){} //设置中介
virtual void SendMessage(string message) {} //向中介发送信息
virtual void GetMessage(string message) {} //从中介获取信息
};
//抽象中介机构
class Mediator
{
public:
virtual void Send(string message, Person *person) {}
virtual void SetA(Person *A) {} //设置其中一方
virtual void SetB(Person *B) {}
};
//租房者
class Renter: public Person
{
public:
void SetMediator(Mediator *mediator) { m_mediator = mediator; }
void SendMessage(string message) { m_mediator->Send(message, this); }
void GetMessage(string message) { cout<<"租房者收到信息"<<message; }
};
//房东
class Landlord: public Person
{
public:
void SetMediator(Mediator *mediator) { m_mediator = mediator; }
void SendMessage(string message) { m_mediator->Send(message, this); }
void GetMessage(string message) { cout<<"房东收到信息："<<message; }
};
//房屋中介
class HouseMediator : public Mediator
{
private:
Person *m_A; //租房者
Person *m_B; //房东
public:
HouseMediator(): m_A(0), m_B(0) {}
void SetA(Person *A) { m_A = A; }
void SetB(Person *B) { m_B = B; }
void Send(string message, Person *person)
{
if(person == m_A) //租房者给房东发信息
m_B->GetMessage(message); //房东收到信息
else
m_A->GetMessage(message);
}
};
int main()
{
Mediator *mediator = new HouseMediator();
Person *person1 = new Renter(); //租房者
Person *person2 = new Landlord(); //房东
mediator->SetA(person1);
mediator->SetB(person2);
person1->SetMediator(mediator);
person2->SetMediator(mediator);
person1->SendMessage("我想在南京路附近租套房子，价格800元一个月\n");
person2->SendMessage("出租房子：南京路100号，70平米，1000元一个月\n");
delete person1; delete person2; delete mediator;
return 0;
}
/**
中介者模式
**/
/**************
**************/
</textarea><br>
<a href="http://blog.csdn.net/hudashi/article/details/50982568/">迭代子模式</a><br>
<textarea id="v">
#include <iostream>
#include <vector>
using namespace std;
template<class Item>
class Iterator
{
public:
virtual void first()=0;
virtual void next()=0;
virtual Item* currentItem()=0;
virtual bool isDone()=0;
virtual ~Iterator(){}
};
template<class Item>
class ConcreteAggregate;
template<class Item>
class ConcreteIterator : public Iterator <Item>
{
ConcreteAggregate<Item> * aggr;
int cur;
public:
ConcreteIterator(ConcreteAggregate<Item>*a):aggr(a),cur(0){}
virtual void first()
{
cur=0;
}
virtual void next()
{
if(cur<aggr->getLen())
cur++;
}
virtual Item* currentItem()
{
if(cur<aggr->getLen())
return &(*aggr)[cur];
else
return NULL;
}
virtual bool isDone()
{
return (cur>=aggr->getLen());
}
};
template<class Item>
class Aggregate
{
public:
virtual Iterator<Item>* createIterator()=0;
virtual ~Aggregate(){}
};
template<class Item>
class ConcreteAggregate:public Aggregate<Item>
{
vector<Item >data;
public:
ConcreteAggregate()
{
data.push_back(1);
data.push_back(2);
data.push_back(3);
}
virtual Iterator<Item>* createIterator()
{
return new ConcreteIterator<Item>(this);
}
Item& operator[](int index)
{
return data[index];
}
int getLen()
{
return data.size();
}
};
int main()
{
Aggregate<int> * aggr =new ConcreteAggregate<int>();
Iterator<int> *it=aggr->createIterator();
for(it->first();!it->isDone();it->next())
{
cout<<*(it->currentItem())<<endl;
}
delete it;
delete aggr;
return 0;
}
/****************
http://blog.csdn.net/hudashi/article/details/50982568/
迭代子模式
提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
*****/
/**************
**************/
</textarea><br>
<textarea id="w">
#include <iostream>
using namespace std;
template <typename T>
class CaffeineBeverage //具有咖啡因饮料
{
public:
void PrepareRecipe() //咖啡因饮料冲泡法
{
cout << " 1.把水煮沸" <<endl;
static_cast<T *>(this)->Brew(); //冲泡
cout << " 3.把咖啡因子材料倒进杯子" <<endl;
static_cast<T *>(this)->Addcs(); //加调料
}
};
class Coffee : public CaffeineBeverage<Coffee>
{
public:
void Brew() { cout << " 2.用沸水冲泡咖啡" <<endl;}
void Addcs() { cout << " 4.加糖和牛奶" <<endl; }
};
class Tea : public CaffeineBeverage<Tea>
{
public:
void Brew() { cout << " 2.用沸水浸泡茶叶" <<endl;}
void Addcs() { cout << " 4.加柠檬" <<endl; }
};
int main()
{
cout << "冲咖啡:" << endl;
Coffee c; c.PrepareRecipe();
cout << "冲杯茶:" << endl;
Tea t; t.PrepareRecipe();
return 0;
}
/**************
【模版类】
【使用类A】【使用类B】
具有共同步骤，特点等，加大对代码的重用率
——————————---------
模版设计
冲杯咖啡:
把水煮沸
用沸水冲泡咖啡
把咖啡倒进杯子
加糖和牛奶
冲杯茶:
把水煮沸
用沸水浸泡茶叶
把咖啡倒进杯子
加柠檬
**************/
</textarea><br>
<textarea>
// http://blog.csdn.net/wuzhekai1985/article/details/6667020
#include <iostream>
using namespace std;
class Resume
{
protected: //保护成员
virtual void SetPersonalInfo() {}
virtual void SetEducation() {}
virtual void SetWorkExp() {}
public:
void FillResume()
{
SetPersonalInfo();
SetEducation();
SetWorkExp();
}
};
class ResumeA: public Resume
{
protected:
void SetPersonalInfo() { cout<<"A‘s PersonalInfo"<<endl; }
void SetEducation() { cout<<"A‘s Education"<<endl; }
void SetWorkExp() { cout<<"A‘s Work Experience"<<endl; }
};
class ResumeB: public Resume
{
protected:
void SetPersonalInfo() { cout<<"B‘s PersonalInfo"<<endl; }
void SetEducation() { cout<<"B‘s Education"<<endl; }
void SetWorkExp() { cout<<"B‘s Work Experience"<<endl; }
}; int main()
{
Resume *HR = new ResumeA();
HR->FillResume();
delete HR;
HR = new ResumeB();
HR->FillResume();
delete HR;
HR = NULL;
return 0;
}
</textarea>
<audio controls="controls" hidden="hidden" autoplay="autoplay" loop="loop">
<source src="1.mp3" type="audio/mpeg" />
</audio>
</center>
</body>
</html>可以直接附件下载
以c++ 设计模式的文本编辑 来自网络的集合 js文字边框闪亮 arc画圆
标签：以c++ 设计模式的文本编辑 来自网络的集合 js文字边框闪亮 arc画圆
原文地址：http://wzsts.blog.51cto.com/10251779/1827741
