行为型设计模式（Behavioral Design Patterns） - 11种

#include <iostream>
#include <string>
using namespace std;

/*
* 责任链模式
*/

// 抽象处理者
class Handler
{
protected:
	Handler* next;
public:
	Handler(Handler* n = nullptr) :next(n) {}
	void SetNext(Handler* n) { next = n; }
	virtual void HandlerRequest(int request) = 0;
	virtual ~Handler() {}
};

// 具体处理者A
class HandlerA :public Handler
{
public:
	void HandlerRequest(int request) override
	{
		if (request <= 7)
		{
			cout << "HandlerA 的处理完成！" << endl;
		}
		else if (next)
		{
			next->HandlerRequest(request);
		}
		else
		{
			cout << "无法处理请求！" << endl;
		}
	}
};

// 具体处理者B
class HandlerB :public Handler
{
public:
	void HandlerRequest(int request) override
	{
		if (request <= 15)
		{
			cout << "HandlerB 的处理完成！" << endl;
		}
		else if (next)
		{
			next->HandlerRequest(request);
		}
		else
		{
			cout << "无法处理请求！" << endl;
		}
	}
};

// 具体处理者C
class HandlerC :public Handler
{
public:
	void HandlerRequest(int request) override
	{
		if (request <= 30)
		{
			cout << "HandlerC 的处理完成！" << endl;
		}
		else if (next)
		{
			next->HandlerRequest(request);
		}
		else
		{
			cout << "无法处理请求！" << endl;
		}
	}
};

int main()
{
	Handler* handlerA = new HandlerA();
	Handler* handlerB = new HandlerB();
	Handler* handlerC = new HandlerC();
	handlerA->SetNext(handlerB);
	handlerB->SetNext(handlerC);

	handlerA->HandlerRequest(5);
	handlerA->HandlerRequest(10);
	handlerA->HandlerRequest(25);
	handlerA->HandlerRequest(35);
}

#include <iostream>
#include <string>
using namespace std;

/*
* 命令链模式
*/

// 请求接收者
class Receiver
{
public:
	void Action1()
	{
		cout << "接收者执行动作1" << endl;
	}
	void Action2()
	{
		cout << "接收者执行动作2" << endl;
	}
	~Receiver() { ; }
};

// 命令接口
class Command
{
public:
	virtual ~Command() { ; }
	virtual void Execute() = 0;
};

// 具体命令1
class Command1 :public Command
{
private:
	Receiver* receiver;
public:
	Command1(Receiver* r) :receiver(r) { ; }
	~Command1() { ; }
	void Execute()
	{
		cout << "执行具体命令1" << endl;
		receiver->Action1();
	}
};

// 具体命令2
class Command2 :public Command
{
private:
	Receiver* receiver;
public:
	Command2(Receiver* r) :receiver(r) { ; }
	~Command2() { ; }
	void Execute()
	{
		cout << "执行具体命令2" << endl;
		receiver->Action2();
	}
};

// 命令调用者
class Invoker
{
private:
	Command* command;
public:
	void SetCommand(Command* cmd)
	{
		command = cmd;
	}
	void ExcuteCommand()
	{
		if (command)
		{
			command->Execute();
		}
	}
	~Invoker() { ; }
};

int main()
{
	Receiver* receiver = new Receiver();

	Command* command1 = new Command1(receiver);
	Command* command2 = new Command2(receiver);

	Invoker* invoker = new Invoker();
	invoker->SetCommand(command1);
	invoker->ExcuteCommand();

	invoker->SetCommand(command2);
	invoker->ExcuteCommand();
}

#include <iostream>
#include <string>
using namespace std;

/*
* 解释器模式
*/

// 抽象表达式类
class Expression
{
public:
	virtual ~Expression() { ; }
	virtual int interpret() = 0;
};

// 终结符表达式：数字
class NumberExpression :public Expression
{
private:
	int number;
public:
	NumberExpression(int num) :number(num) {}
	~NumberExpression() { ; }
	int interpret() override
	{
		return number;
	}
};

// 非终结符表达式：加法
class AddExpression :public Expression
{
private:
	Expression* left;
	Expression* right;
public:
	AddExpression(Expression* l, Expression* r) :left(l), right(r) {}
	~AddExpression() { ; }
	int interpret() override
	{
		return left->interpret() + right->interpret();
	}
};

// 非终结符表达式：乘法
class MulExpression :public Expression
{
private:
	Expression* left;
	Expression* right;
public:
	MulExpression(Expression* l, Expression* r) :left(l), right(r) {}
	~MulExpression() { ; }
	int interpret() override
	{
		return left->interpret() * right->interpret();
	}
};

// 解释器上下文
class Context
{
private:
	Expression* expression;
public:
	void setExpression(Expression* exp)
	{
		expression = exp;
	}
	int interpret()
	{
		if (expression)
		{
			return expression->interpret();
		}
		return 0;
	}
	~Context() { ; }
};

int main()
{
	Expression* number1 = new NumberExpression(1);
	Expression* number2 = new NumberExpression(2);

	Expression* addExpression = new AddExpression(number1, number2);

	Context context;
	context.setExpression(addExpression);

	int result = context.interpret();
	cout << "result: " << result << endl;
	cout << "=================================" << endl;
	Expression* number3 = new NumberExpression(3);
	Expression* number4 = new NumberExpression(4);
	Expression* mulExpression = new MulExpression(number3, number4);
	context.setExpression(mulExpression);
	result = context.interpret();
	cout << "result: " << result << endl;
}

#include <iostream>
#include <vector>
using namespace std;

/*
* 迭代器模式
*/

// 迭代器接口
class Iterator
{
public:
	virtual int next() = 0;
	virtual bool hasNext() = 0;
};

// 集合接口
class Collection
{
public:
	virtual Iterator* CreateIterator() = 0;
};

// 具体迭代器1
class Iterator1 :public Iterator
{
private:
	vector<int> collection;
	int index;
public:
	Iterator1(vector<int> coll) :collection(coll), index(0) { ; }
	int next() override
	{
		return collection[index++];
	}
	bool hasNext() override
	{
		return index < collection.size();
	}
};

// 具体集合1
class Collection1 :public Collection
{
private:
	vector<int> collection;
public:
	void Add(int num)
	{
		collection.push_back(num);
	}
	Iterator* CreateIterator() override
	{
		return new Iterator1(collection);
	}
};

int main()
{
	Collection1 collection1;
	collection1.Add(1);
	collection1.Add(2);
	collection1.Add(3);

	Iterator* iterator = collection1.CreateIterator();
	while (iterator->hasNext())
	{
		cout << iterator->next() << " ";
	}
	cout << std::endl;
}

#include <iostream>
#include <string>
using namespace std;

/*
* 中介者模式
*/

// 中介者接口
class Mediator
{
public:
	virtual void SendMessage(string message, class Colleague* colleague) = 0;
};

// 同事类接口
class Colleague
{
protected:
	string message;
	Mediator* mediator;
public:
	Colleague(Mediator* m) :mediator(m) { ; }
	virtual void ReceiveMessage(string message) = 0;
	virtual void SendMessage(string message) = 0;
};

// 具体同事A
class ColleagueA :public Colleague
{
public:
	ColleagueA(Mediator* m) :Colleague(m) { ; }
	virtual void ReceiveMessage(string message) override
	{
		cout << "ColleagueA receive message: " << message << endl;
	}
	virtual void SendMessage(string message) override
	{
		mediator->SendMessage(message, this);
	}
};

// 具体同事B
class ColleagueB :public Colleague
{
public:
	ColleagueB(Mediator* m) :Colleague(m) { ; }
	virtual void ReceiveMessage(string message) override
	{
		cout << "ColleagueB receive message: " << message << endl;
	}
	virtual void SendMessage(string message) override
	{
		mediator->SendMessage(message, this);
	}
};

class ConcreteMediator :public Mediator
{
private:
	Colleague* colleagueA;
	Colleague* colleagueB;
public:
	void SetColleagueA(Colleague* colleague) { colleagueA = colleague; }
	void SetColleagueB(Colleague* colleague) { colleagueB = colleague; }
	void SendMessage(string message, Colleague* colleague) override
	{
		if (colleague == colleagueA)
		{
			colleagueB->ReceiveMessage(message);
		}
		else if (colleague == colleagueB)
		{
			colleagueA->ReceiveMessage(message);
		}
	}
};

int main()
{
	ConcreteMediator* mediator = new ConcreteMediator();

	Colleague* colleagueA = new ColleagueA(mediator);
	Colleague* colleagueB = new ColleagueB(mediator);
	mediator->SetColleagueA(colleagueA);
	mediator->SetColleagueB(colleagueB);
	colleagueA->SendMessage("你好啊！同事B");
	colleagueB->SendMessage("你好啊！同事A");
}

#include <iostream>
#include <string>
using namespace std;

/*
* 备忘录模式
*/

// 备忘录类
class Memento
{
private:
	string state;
public:
	Memento() { ; }
	Memento(string s)
	{
		state = s;
	}
	string GetState()
	{
		return state;
	}
};

// 原发器
class Originator
{
private:
	string state;
public:
	Originator(string s) :state(s) { ; }
	void SetState(string s)
	{
		state = s;
	}
	string GetState()
	{
		return state;
	}
	Memento CreateMemento()
	{
		return Memento(state);
	}
	void SetMemento(Memento memento)
	{
		state = memento.GetState();
	}
};

// 管理者类
class Caretaker
{
private:
	Memento memento;
public:
	void SaveMemento(const Memento& m)
	{
		memento = m;
	}
	Memento RetrieveMemento()
	{
		return memento;
	}
};

int main()
{
	Caretaker caretaker;
	Originator originator("状态1");
	cout << "初始状态：" << originator.GetState() << endl;
	caretaker.SaveMemento(originator.CreateMemento());
	originator.SetState("状态2");
	cout << "修改状态：" << originator.GetState() << endl;
	originator.SetMemento(caretaker.RetrieveMemento());
	cout << "恢复状态：" << originator.GetState() << endl;
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;

/*
* 观察者模式
*/

// 抽象观察者类
class Observer
{
public:
	virtual void Update() = 0;
};

// 抽象主题类
class Subject
{
public:
	virtual void Attach(Observer* observer) = 0;
	virtual void Detach(Observer* observer) = 0;
	virtual void Notify() = 0;
};

// 具体观察者1
class Observer1 :public Observer
{
private:
	string name;
	Subject* subject;
public:
	Observer1(string n, Subject* s) :name(n), subject(s)
	{
		subject->Attach(this);
	}
	Observer1(string n) :name(n) { ; }
	void Update() override
	{
		cout << "观察者：" << name << "收到更新通知！" << endl;
	}
};

// 具体观察者2
class Observer2 :public Observer
{
private:
	string name;
	Subject* subject;
public:
	Observer2(string n, Subject* s) :name(n), subject(s)
	{
		subject->Attach(this);
	}
	Observer2(string n) :name(n) { ; }
	void Update() override
	{
		cout << "观察者：" << name << "收到更新通知！" << endl;
	}
};

// 具体主题1
class Subject1 :public Subject
{
private:
	vector<Observer*> observers;
public:
	void Attach(Observer* observer) // 添加观察者
	{
		observers.push_back(observer);
	}
	void Detach(Observer* observer) // 删除观察者
	{
		for (auto it = observers.begin(); it != observers.end(); ++it)
		{
			if (*it == observer)
			{
				observers.erase(it);
				break;
			}
		}
	}
	void Notify() // 通知观察者
	{
		cout << "通知所有的观察者..." << endl;
		for (auto it : observers)
		{
			it->Update();
		}
	}
};

int main()
{
	Subject1* subject1 = new Subject1();
	Observer* observer1 = new Observer1("observer1", subject1);
	Observer* observer2 = new Observer2("observer2", subject1);
	//Observer* observer1 = new Observer1("observer1");
	//Observer* observer2 = new Observer2("observer2");
	//subject1->Attach(observer1);
	//subject1->Attach(observer2);
	subject1->Notify();
	cout << "==========分割线=============" << endl;
	subject1->Detach(observer2);
	subject1->Notify();
}

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
using namespace std;

/*
* 状态者模式
*/

class Context; // 前向声明
class StateA; // 前向声明

// 抽象状态类
class State
{
public:
	virtual void Handle(Context* context) = 0;
};

// 状态类B
class StateB :public State
{
public:
	void Handle(Context* context) override;
};

// 状态类A
class StateA :public State
{
public:
	void Handle(Context* context) override;
};

// 贩卖机
class Context
{
private:
	int count;
	State* state;
public:
	Context()
	{
		count = 3;
		state = new StateA();
	}
	int GetCount()
	{
		return count;
	}
	void SetCount(int c)
	{
		count = c;
	}
	State* GetState()
	{
		return state;
	}
	void SetState(State* s)
	{
		state = s;
	}
	void Request()
	{
		state->Handle(this);
	}
};

// StateA 类成员函数定义
void StateA::Handle(Context* context)
{
	int count = context->GetCount();
	if (count >= 1)
	{
		cout << "购买成功！" << endl;
		context->SetCount(count - 1);
		if (count - 1 == 0)
		{
			context->SetState(new StateB());
		}
	}
	else
	{
		cout << "库存无货，购买失败！" << endl;
	}
}

// StateB 类成员函数定义
void StateB::Handle(Context* context)
{
	int count = context->GetCount();
	if (count == 0)
	{
		cout << "库存无货，购买失败！" << endl;
		context->SetCount(5);
		cout << "补货成功，可重新购买！" << endl;
	}
}

int main()
{
	Context* context = new Context();
	cout << typeid(*context->GetState()).name() << endl;
	context->Request();
	context->Request();
	context->Request();
	cout << typeid(*context->GetState()).name() << endl;
	context->Request();
	cout << typeid(*context->GetState()).name() << endl;
}

#include <iostream>
using namespace std;

/*
* 策略模式
*/

// 策略接口
class Strategy
{
public:
	virtual void TwoNumberOperation(int a, int b) = 0;
};

// 具体策略A
class StrategyA :public Strategy
{
public:
	void TwoNumberOperation(int a, int b) override
	{
		cout << a + b << endl;
	}
};

// 具体策略B
class StrategyB :public Strategy
{
public:
	void TwoNumberOperation(int a, int b) override
	{
		cout << a - b << endl;
	}
};

// 具体策略C
class StrategyC :public Strategy
{
public:
	void TwoNumberOperation(int a, int b) override
	{
		cout << a * b << endl;
	}
};

class Context
{
protected:
	Strategy* strategy;
public:
	Context(Strategy* s) { strategy = s; }
	void Operation(int a, int b)
	{
		strategy->TwoNumberOperation(a, b);
	}
};

int main()
{
	Strategy* strategyA = new StrategyA();
	Strategy* strategyB = new StrategyB();
	Strategy* strategyC = new StrategyC();
	Context* context = new Context(strategyA);
	context->Operation(2, 3);
	context = new Context(strategyB);
	context->Operation(2, 3);
	context = new Context(strategyC);
	context->Operation(2, 3);
}

#include <iostream>
#include <string>
using namespace std;

/*
* 模板方法模式
*/

class Person
{
public:
	void TemplateMethod()
	{
		cout << "去教室" << endl;
		PrimitiveOperation1();
		cout << "离开教室" << endl;
		PrimitiveOperation2();
	}
	virtual void PrimitiveOperation1() = 0;
	virtual void PrimitiveOperation2() = 0;
};

class Student :public Person
{
	void PrimitiveOperation1()
	{
		cout << "学生听课" << endl;
	}
	void PrimitiveOperation2()
	{
		cout << "学生写作业" << endl;
	}
};

class Teacher :public Person
{
	void PrimitiveOperation1()
	{
		cout << "老师上课" << endl;
	}
	void PrimitiveOperation2()
	{
		cout << "老师布置作业" << endl;
	}
};

int main()
{
	Person* student = new Student();
	Person* teacher = new Teacher();
	student->TemplateMethod();
	cout << "================================" << endl;
	teacher->TemplateMethod();
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;

/*
* 访问者模式
*/

class ElementA;
class ElementB;

// 访问者接口
class Visitor
{
public:
	virtual void visit(ElementA* elementA) = 0;
	virtual void visit(ElementB* elementB) = 0;
};

// 元素接口
class Element
{
public:
	virtual void accept(Visitor* visitor) = 0;
};

// 具体元素A
class ElementA :public Element
{
public:
	void accept(Visitor* visitor) override
	{
		visitor->visit(this);
	}
	void OperationA()
	{
		cout << "元素 A 的方法" << endl;
	}
};

// 具体元素B
class ElementB :public Element
{
public:
	void accept(Visitor* visitor) override
	{
		visitor->visit(this);
	}
	void OperationB()
	{
		cout << "元素 B 的方法" << endl;
	}
};

// 具体访问者
class ConcreteVisitor :public Visitor
{
public:
	void visit(ElementA* elementA) override
	{
		cout << "访问者访问元素 A 的方法：" << endl;
		elementA->OperationA();
	}
	void visit(ElementB* elementB) override
	{
		cout << "访问者访问元素 B 的方法：" << endl;
		elementB->OperationB();
	}
};

// 对象结构体类
class ObjectStructure
{
private:
	vector<Element*>elements;
public:
	void  AddElement(Element* element)
	{
		elements.push_back(element);
	}
	void accept(Visitor* visitor)
	{
		for (auto element : elements)
		{
			element->accept(visitor);
		}
	}
};

int main()
{
	ElementA elementA;
	ElementB elementB;
	ConcreteVisitor visitor;
	ObjectStructure objectStructure;
	objectStructure.AddElement(&elementA);
	objectStructure.AddElement(&elementB);
	objectStructure.accept(&visitor);
}