C++ 观察者模式/备忘录模式/访问者模式(含代码)

观察者模式定义对象间的一种一对多的依赖关系。当一个对象的状态发生改变时，所有依赖于他的对象都会得到通知，并被自动更新.

#include
#include"string"
#include"list"
using namespace std;

class PlayserObserver
{
public:
	PlayserObserver(Secretary *secretary)
	{
		this->m_secretary = secretary;

	}
	void update(string action)
	{
		cout << "action:" << action << endl;
	}
private:
	Secretary *m_secretary;
};
class Secretary
{
public:
	Secretary()
	{
		m_list.clear();
	}
	void Notify(string info)
	{
		for (list::iterator it = m_list.begin(); it != m_list.end(); it++)
		{
			(*it)->update(info);
		}
	}
	void setPlayserObserver(PlayserObserver *o)
	{
		m_list.push_back(o);
	}
private:
	list m_list;
};
void main()
{
	Secretary *secretary = NULL;
	PlayserObserver *po1 = NULL;
	PlayserObserver *po2 = NULL;
	secretary = new Secretary;
	po1 = new PlayserObserver(po1);
	po2 = new PlayserObserver(po2);

	secretary->Notify("我来了");
	secretary->Notify("我走了");
	delete secretary;
	delete po1;
	delete po2;
	system("pause");
	return;
}

备忘录模式是在不破坏封装的前提下，捕获一个对象的内部状态，并在该状态之外保存这个状态

#include
#include"string"
using namespace std;
#include"list"
class MememTo
{
public:
	MememTo(string name, int age)
	{
		m_name = name;
		m_age = age;
	}
	string  getName()
	{
		return m_name;
	}
	int getAge()
	{
		return m_age;
	}
	void setName(string name)
	{
		this->m_name = name;
	}
	void getAge(int age)
	{
		this->m_age = age;
	}
private:
	string   m_name;
	int      m_age;
};
class Person
{
public:
	Person(string  name, int age)
	{
		m_name = name;
		m_age = age;
	}
	string  getName()
	{
		return m_name;
	}
	int getAge()
	{
		return m_age;
	}
	void setName(string name)
	{
		this->m_name = name;
	}
	void setAge(int age)
	{
		this->m_age = age;
	}
	//保存
	MememTo*  createMememTo()
	{
		return new MememTo(m_name, m_age);
	}
	//还原
	void setMememTo(MememTo* memto)
	{
		this->m_age = memto->getAge();
		this->m_name = memto->getName();
	}
public:
	void printT()
	{
		cout << "m_name:" << m_name << "m_age:" << m_age << endl;
	}
private:
	string   m_name;
	int      m_age;
};
void main11()
{
	MememTo *memto = NULL;
	Person *p = new Person("张三", 32);
	p->printT();
	//创建 对象的一个状态
	p->createMememTo();
	memto= p->createMememTo();
	p->setAge(42);
	p->printT();

	printf("还原旧的状态
");
	delete p;
	delete memto;
}
void main()
{
	main11();
	cout << "hello..." << endl;
	system("pause");
	return;
}

访问者模式就是表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义使用这些元素的新操作

把数据结构和作用于数据结构上的操作进行解耦合，适用于数据结构比较稳定的场合

访问者模式总结，访问者模式的优点是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。那访问者模式的缺点是增加新的数据结构变得困难

案例需求

比如有一个公园，有一到多个不同的组成部分，该公园存在多个访问者，清洁工a负责打扫公园的a部分清洁工，B负责打扫公园的B部分，公园的管理者负责检点各项事务是否完成，上级领导可以视察公务员等等。也就是说，对于同一个公园，不同的访问者会有不同的行为操作，而且访问者的种类也可能会。需要根据时间的推移而变化，这叫什么?行为的扩展性根据软件设计的开闭原则，什么叫开闭原则？对修改关闭，对拓展开放，我们怎么样实现这种需求呢？

#include
#include"string"
#include"list"
using namespace std;

class Visitor
{
public:
	virtual void visit(ParkElement *parkelement) = 0;
};
class ParkElement
{
public:
	virtual void accept(Visitor *visit) = 0;
};
class ParkA :public ParkElement
{
public:
	virtual void accept(Visitor *v)
	{
		v->visit(this);
	}
};
class ParkB :public ParkElement
{
public:
	virtual void accept(Visitor *v)
	{
		v->visit(this);
	}
};
class Park :public ParkElement
{
public:
	Park()
	{
		m_list.clear();
	}
	void setParkElement(ParkElement *pe)
	{
		m_list.push_back(pe);
	}
public:
	virtual void accept(Visitor *v)
	{
		for (list::iterator it = m_list.begin(); it != m_list.end(); it++)
		{
			(*it)->accept(v);
		}
	}
private:
	list m_list;//公园的每一部分,公园的每一个部分都让管理者访问
};
class VisitorA :public Visitor
{
public:
	virtual void visit(ParkElement *parkelement)
	{
		cout << " A打扫" << endl;
	}
};
class VisitorB :public Visitor
{
public:
	virtual void visit(ParkElement *parkelement)
	{
		cout << "B打扫 " << endl;
	}
};
class ManagerVisitor :public Visitor
{
public:
	virtual void visit(ParkElement *parkelement)
	{
		cout << " 管理者访问公园的各个部分" << endl;
	}
};
void  main11()
{
	Visitor *vA = new VisitorA;
	Visitor *vB = new VisitorB;
	ParkA *parkA = new ParkA;
	ParkB *parkB = new ParkB;
	ParkA->accept(vA);
	ParkB->accept(vB);
	delete vA;
	delete vB;
	delete parkA;
	delete parkB;

}
void main12()
{
	Visitor *vManger = new MangerVisitor;
	Park *park = new Park;
	ParkElement *ParkA = new ParkA;
	ParkElement *ParkB = new ParkB;

	park->setParkElement(ParkA);
	park->setParkElement(ParkB);


	//整个公园接受管理者访问
	park->accept(vManger);
	

}
void main()
{
	main11();
	main12();
	cout << "hello..." << endl;
	system("pause");
	return;
}