C++ 设计模式之组合模式/外观模式/享元模式(含代码)

组合模式是将对象组合成树形结构，以表示整体部分的层次结构，使得用户对单个对象和组合对象的使用具有一致性

#include
using namespace std;
#include"string"
#include"list"
class IFile
{
public:
	virtual void display() = 0;
	virtual int add(IFile *ifile) = 0;
	virtual int remove(IFile *ifile) = 0;
	virtual listgetChild() = 0;
};
class File :public IFile
{
public:
	File(string name)
	{
		m_name = name;
	}
	virtual void display()
	{
		cout << m_name << endl;
	}
private:
	string  m_name;
};
class Dir
{
public:
	Dir(string name)
	{
		m_name = name;
		m_list = new list;
		m_list->clear();
	}
	virtual void display()
	{
		cout << m_name << endl;
	}
	virtual int add(IFile *ifile)
	{
		m_list->push_back(ifile);
		return 0;
	}
	virtual int remove(IFile *ifile)
	{
		m_list->remove(ifile);
		return 0;
	}
	virtual list  getChild()
	{
		return m_list;
	}
private:
	string  m_name;
	list  *m_list;
};
void main()
{
	Dir *root = new Dir("c");
	Dir *dirl= new Dir("llldir");
	File *aaafile=new File("aaa.txt");

	root->display();
	//获取root结点下的 孩子集合
	list *list = root->getChild();
	root->add(dirl);
	root->add(aaafile);

	for (list::iterator it = mylist->begin();it!= mylist->end(); it++)
	{
		(*it)->display();
	}
	system("pause");
	return;
}

外观模式是为子系统中的一组接口提供一个一致的界面，此模式定义一个高层接口，这个接口使得这一子系统更加容易使用

#include
using namespace std;
class SubSystemA
{
public:
	void doThing()
	{
		cout << "SubSystemA run" << endl;
	 }
};
class SubSystemB
{
public:
	void doThing()
	{
		cout << "SubSystemA run" << endl;
	}
};
class SubSystemC
{
public:
	void doThing()
	{
		cout << "SubSystemA run" << endl;
	}
};
class Facade
{
public:
	Facade()
	{
		sysA = new SubSystemA;
		 sysB = new SubSystemB;
		 sysC = new SubSystemC;
	}
	~Facade()
	{
	
		delete sysA;
		delete sysB;
		delete sysC;
	
	}

public:
	void doThing()
	{
		sysA->doThing();
		sysB->doThing();
		sysC->doThing();
	}

private:
	SubSystemA *sysA;
	SubSystemB *sysB;
	SubSystemC *sysC;
};


void main11()
{
	SubSystemA *sysA = new SubSystemA;
	SubSystemB *sysB = new SubSystemB;
	SubSystemC *sysC = new SubSystemC;
	sysA->doThing();
	sysB->doThing();
	sysC->doThing();
	delete sysA;
	delete sysB;
	delete sysC;
	system("pause");
	return;

}
void mian22()
{
	Facade *f = new Facade;
	f->doThing();
	delete f;
}
void mian()
{
	main11();
	mian22();
	system("pause");
	return;
}

享元模式是以共享的方式高效地支持大量的细粒度的对象

在面向对象系统的设计和实现中，创建对象是最为常见的一种操作。这里面就有一个问题，如果一个应用程序使用了太多的对象，就会造成很大的存储开销，特别是对于大量轻量级的对象，比如在文档编辑器的设计过程，我们如果为所有字母创建一个对象的话，系统可能会因为大量的对象而造成存储开销的浪费，例如一个字母a在文档中出现了1万次。而实际上，我们可以让这10000个字母共享一个对象，当然因为在不同的位置，字母也有不同的显示效果，比如说字体的大小设置不同。在这种情况下，我们可以将对象的状态分为外部对象状态和内部状态。将可以被共享、不会被变化的状态，作为内部状态存储在对象中，而外部对象，假如上面提到的字体大小，我们可以在适当的时候将外部对象。作为参数传递给对象

include
using namespace std;
#include"string"
class Person
{
public:
	Person(string name, int age)
	{
		this->m_name = name;
		this->age = age;
	}
protected:
	string name;
	int    age;
};
class Teacher :public Person
{
	Teacher(string name, int age, string id) :Person(name, age)
	{
		this->m_id = id;
	}
	void printT()
	{

		cout << "name:" << m_name << "age:" << age << "m_id" << m_id << endl;
	}

private:
	string    m_id;
};
class FlyWeightTeacherFactory
{
public:
	Person* GetTeacher(string id)
	{
		return NULL;
	}
};
void main()
{
	Person*p1 = NULL;
	Person*p2 = NULL;

	FlyWeightTeacherFactory *fwtf = new FlyWeightTeacherFactory;
	p1=fwtf->GetTeacher("001");
	p1->printT();
	p2 = fwtf->GetTeacher("001");
	p2->printT();
	delete fwtf;
	system("pause");
	return;
}

行为型模式