代码仅作结构展示,有BUG
还在补充中
#include <iostream>
#include <list>
#include <cstring>
//外观模式 Facade 12
namespace NFacade
{
//四个子系统类
class SubSystemOne
{
public:
void Method1()
{
std::cout << std::endl << "SubSystemOne::Method1";
}
};
class SubSystemTwo
{
public:
void Method2()
{
std::cout << std::endl << "SubSystemTwo::Method2";
}
};
class SubSystemThree
{
public:
void Method3()
{
std::cout << std::endl << "SubSystemThree::Method3";
}
};
class SubSystemFour
{
public:
void Method4()
{
std::cout << std::endl << "SubSystemFour::Method4";
}
};
//外观类
class Facade
{
SubSystemOne one;
SubSystemTwo two;
SubSystemThree three;
SubSystemFour four;
public:
void MethodOne()
{
one.Method1();
three.Method3();
}
void MethodTwo()
{
two.Method2();
four.Method4();
}
};
//客户端调用 main
void Client()
{
Facade facade;
facade.MethodOne();
facade.MethodTwo();
}
}
//建造者模式 Builder 13
namespace NBuilder
{
//产品类
class Product
{
std::list<std::string> parts;
public:
void Add(std::string part)
{
parts.push_back(part);
}
void Show()
{
//do something
}
};
//Builder类
class Builder
{
public:
virtual void BuildPartA() = 0;
virtual void BuildPartB() = 0;
virtual Product GetResoult() = 0;
};
//具体建造者类1
class ConcreteBuilder1 :Builder
{
Product product;
public:
void BuildPartA()
{
product.Add("part A");
}
void BuildPartB()
{
product.Add("part B");
}
Product GetResoult()
{
return product;
}
};
//具体建造者类2
class ConcreteBuilder2 :Builder
{
Product product;
public:
void BuildPartA()
{
product.Add("part X");
}
void BuildPartB()
{
product.Add("part Y");
}
Product GetResoult()
{
return product;
}
};
//指挥者类
class Director
{
public:
void Construct(Builder* builder)
{
builder->BuildPartA();
builder->BuildPartB();
}
};
//客户端代码
void Client()
{
Director director;
Builder* b1 = (Builder*)new ConcreteBuilder1();
Builder* b2 = (Builder*)new ConcreteBuilder2();
director.Construct(b1);
Product p1 = b1->GetResoult();
p1.Show();
director.Construct(b2);
Product p2 = b2->GetResoult();
p2.Show();
}
}
//观察者模式 发布-订阅模式 14
namespace NObserver
{
//抽象观察者
class Observer
{
public:
virtual void Update() = 0;
};
//主题类,通知者
class Subject
{
std::list<Observer*>observers;
public:
void Attach(Observer* pobserver)
{
observers.push_back(pobserver);
}
void Detach()
{
observers.pop_back();//需要delete
}
void Notify()
{
for (auto observer : observers)
{
observer->Update();
}
}
};
//具体通知者
class ConcreteSubject :public Subject
{
std::string subjectState;
public:
void Set(std::string s) { subjectState = s; }
std::string Get() { return subjectState; }
};
//具体观察者
class ConcreteObserver :Observer
{
std::string name;
std::string observerState;
ConcreteSubject* pSubject;
public:
ConcreteObserver(ConcreteSubject* psubject, std::string n)
{
pSubject = psubject;
name = n;
}
void Update()
{
observerState = pSubject->Get();
//dosomething
}
void Set(ConcreteSubject* pc) { pSubject = pc; }
ConcreteSubject* Get() { return pSubject; }
};
//客户端
void Client()
{
ConcreteSubject s;
s.Attach((Observer*)new ConcreteObserver(&s, "X"));
s.Attach((Observer*)new ConcreteObserver(&s, "Y"));
s.Attach((Observer*)new ConcreteObserver(&s, "Y"));
s.Set("ABC");
s.Notify();
}
}
//抽象工厂模式 15
//状态模式 16
namespace NState
{
class Context;
class ConcreteStateA;
class ConcreteStateB
{
public:
void Handle(Context* pcontext);
};
class State
{
public:
virtual void Handle(Context* pcontext) = 0;
};
class Context
{
State* pState;
public:
Context(State* pstate)
{
pState = pstate;
}
void Set(State* pstate)
{
delete(pState);//自己加的
pState = pstate;
//do something
}
//Get
void Request()
{
pState->Handle(this);
}
};
class ConcreteStateA :State
{
public:
void Handle(Context* pcontext)
{
pcontext->Set((State*)new ConcreteStateB());
}
};
void ConcreteStateB::Handle(Context* pcontext)
{
pcontext->Set((State*)new ConcreteStateA());
}
//
void Client()
{
Context c((State*)new ConcreteStateA());
c.Request();//不断请求,同时改变状态
c.Request();
c.Request();
c.Request();
c.Request();
}
}
//适配器模式 17 略
//备忘录模式 18
namespace NMemento
{
//备忘录类
class Memento
{
public:
std::string state;
Memento(std::string s)
{
state = s;
}
};
//发起人类
class Originator
{
public:
std::string state;
Memento* CreateMemento()
{
return new Memento(state);
}
void SetMemento(Memento* pmemento)
{
state = pmemento->state;
}
void Show()
{
//显示数据
}
};
//管理者类
class Caretaker
{
public:
Memento* memento;
};
//客户端
void Client()
{
Originator o;
o.state = "On";
o.Show();
Caretaker c;
c.memento = o.CreateMemento();
o.state = "off";
o.Show();
//恢复初始状态
o.SetMemento(c.memento);
o.Show();
}
}
//组合模式
namespace NComposite
{
class Component
{
protected:
std::string name;
public:
Component(std::string s)
{
name = s;
}
virtual void Add(Component* c) = 0;
virtual void Remove(Component* c) = 0;
virtual void Display(int depth) = 0;
};
class Leaf :Component
{
public:
Leaf(std::string s) :Component(s)
{}
void Add(Component* c)
{
//err
}
void Remove(Component* c)
{
//err
}
void Display(int depth)
{
std::cout << depth << name;
}
};
class Composite :Component
{
std::list<Component*>children;
public:
Composite(std::string s):Component(s)
{}
void Add(Component* c)
{
children.push_back(c);
}
void Remove(Component* c)
{
children.pop_back();
}
void Display(int depth)
{
std::cout << depth << name;
for (auto i : children)
{
i->Display(depth + 2);
}
}
};
//客户端
void Client()
{
Composite root("root");
root.Add((Component*)new Leaf("Leaf A"));
root.Add((Component*)new Leaf("Leaf B"));
Composite comp("comp");
comp.Add((Component*)new Leaf("Leaf XA"));
comp.Add((Component*)new Leaf("Leaf XB"));
root.Add((Component*)&comp);
Composite comp2("comp");
comp2.Add((Component*)new Leaf("Leaf XYA"));
comp2.Add((Component*)new Leaf("Leaf XYB"));
comp.Add((Component*)& comp2);
root.Display(1);
}
}
int main()
{
std::cout << "Hello World!\n";
}