设计模式 C++ 代码示例

代码仅作结构展示，有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";
}