通过例子学设计模式之--组合模式以及使用场景说明(C++实现)

        组合模式是一个常用的模式，关于定义和类图网上很多。这里就不重复了。
        本文主要说明下主要的使用场景。希望能够通过通俗易懂的方式把组合模式记住。
        组合模式非常适合有递归迭代性质的结构或者逻辑。即结构上存在树型或者包含关系，逻辑上"整体"和"部分"的行为和状态的对外表现是一致的，或者是类似的。下面通过例子来说明吧。

         比如目录和文件，目录可以只包含子目录，也可以只包含文件，当然可以同时包含子目录和文件。而子目录又可以包含子目录或者文件。

         目录和文件都可以删除或者打开。打开目录其实就是打开目录的全部子目录和该目录下的文件。删除文件就是删除一个文件，删除目录是删除全部子目录和全部文件。   

         再比如公司，部门和员工。公司可以只包含员工，也可以只包含部门，也可以包含子公司，当然可以同时包含员工和部门和子公司。而子公司又可以包含子公司或者部门。

        公司和部门都可以组织开会。全公司开会其实就是组织各个子公司开会。各个子公司开会其实就是各种子公司的全部部门和员工开会。各个部门开会其实就是该部门的全部员工开会。

         组合模式就是抽象出相同的逻辑或者状态，使得访问"整体"和“部分”达到高度统一。

         下面是C++的一个简单例子。我们可以把Open函数理解为“打开文件或者打印目录”，那么应该会很好理解。

          

/* 对"整体"和"部分"的统一接口抽象 */
class Component
{
public:
	Component(string name)
	{
		m_strName = name;
	}

	virtual ~Component(){};
	
	virtual void Add(Component* pComponent) = 0;
	virtual void Del(Component* pComponent) = 0;
	virtual void Open() = 0; 
	
	string m_strName;
};

/* 抽象细粒度不可再分的"部分",比如文件，员工等 */
class Leaf : public Component
{
public:
	Leaf(string name) : Component(name)
	{
	}

	virtual ~Leaf()
	{
		printf("Leaf: \"%s\" Destructor.\r\n",m_strName.c_str());
	};

	virtual void Add(Component* pComponent)
	{
		printf("I'm a leaf.Don't support Add.\r\n");
	}
	virtual void Del(Component* pComponent)
	{
		printf("I'm a leaf.Don't support Del.\r\n");
	}
	virtual void Open()
	{
		printf("Leaf: \"%s\" Open.\r\n",m_strName.c_str());
	}
};

/* 具体的"子结构"或者"整体",比如目录，公司，子公司等等 */
class Composite : public Component
{
public:
	Composite(string name) : Component(name)
	{

	}

	/* 需要销毁全部子结构 */
	virtual ~Composite()
	{
		printf("Composite: \"%s\" Destructor.\r\n",m_strName.c_str());
		for (vector<Component *>::iterator it = m_vComponent.begin(); it != m_vComponent.end(); ++it)
		{
			delete (*it);
		}
	};

	virtual void Add(Component* pComponent)
	{
		m_vComponent.push_back(pComponent);
	}
	virtual void Del(Component* pComponent)
	{
		for (vector<Component *>::iterator it = m_vComponent.begin(); it != m_vComponent.end(); ++it)
		{
			if (*it == pComponent)
			{
				delete *it;
				*it = NULL;

				m_vComponent.erase(it);
				break;
			}
		}
	}
	virtual void Open()
	{
		printf("Composite: \"%s\" Open.\r\n",m_strName.c_str());
		for (vector<Component *>::iterator it = m_vComponent.begin(); it != m_vComponent.end(); ++it)
		{
			(*it)->Open(); //统一调用各个子对象的Open方法
		}
	}

	vector<Component*> m_vComponent;
};

void TestComposite()
{
	Component* root = new Composite("Root");

	root->Add(new Leaf("Root Leaf_A"));
	root->Add(new Leaf("Root Leaf_B"));

	Component* compon1 = new Composite("Root Sub_A");
	Component* compon2 = new Composite("Root Sub_B");

	compon1->Add(new Leaf("Root Sub_A Leaf_A"));
	compon1->Add(new Leaf("Root Sub_A Leaf_B"));

	compon2->Add(new Leaf("Root Sub_B Leaf_A"));
	compon2->Add(new Leaf("Root Sub_B Leaf_B"));

	root->Add(compon1);
	root->Add(compon2);

	Component* leaf3 = new Leaf("Root Sub_A Leaf_CC");

	compon1->Add(leaf3);

	printf("\r\nOpen Root:\r\n");
	root->Open();//打开Root，打开Leaf，打开Composite对外展现的都是一样的方式

	printf("\r\nOpen compon1:\r\n");
	compon1->Open();

	printf("\r\nOpen compon2:\r\n");
	compon2->Open();

	printf("\r\nOpen leaf3:\r\n");
	leaf3->Open();

	printf("\r\nDelete Root:\r\n");
	delete root; //销毁root，会一直递归销毁全部子结构
}