设计模式学习笔记-结构式模式-Composite 模式

Component.h（基类：组成部分、组件，拥有基础操作）

#pragma once
class Component
{
public:
	Component();
	~Component();

	virtual void Operation() = 0;
	virtual void Add(const Component&);
	virtual void Remove(const Component&);
	virtual Component* GetChild(int);
};

Component.cpp

#include "Component.h"

Component::Component()
{
}


Component::~Component()
{
}

void Component::Add(const Component &)
{
}

void Component::Remove(const Component &)
{
}

Component * Component::GetChild(int)
{
	return nullptr;
}

Composite.h（合成物，管理组件）

#pragma once
#include "Component.h"
#include <vector>
using namespace std;

class Composite:public Component
{
public:
	Composite();
	~Composite();

	void Operation();
	void Add(Component* com);
	void Remove(Component* com);
	Component* GetChild(int index);

private:
	vector<Component*> comVec;
	/*提供对于子节点（Leaf）的管理策略，这里
	使用的是 STL 中的 vector，可以提供其他的实现方式，
	如数组、链表、Hash 表等*/
};

Composite.cpp

#include "Composite.h"

Composite::Composite()
{
}


Composite::~Composite()
{
}

//执行Composite（合成物）的操作：所有Component（组件）的操作
void Composite::Operation()
{
	vector<Component*>::iterator comIter = comVec.begin();
	for (;comIter!=comVec.end() ;comIter++)
	{
		(*comIter)->Operation();
	}
}

//给Composite（合成物）添加一个Component（组件）
void Composite::Add(Component* com)
{
	comVec.push_back(com);
}

//移除Composite（合成物）的一个Component（组件）
void Composite::Remove(Component* com)
{
	for (auto iter = comVec.begin(); iter != comVec.end();iter++)
	{
		if (*iter==com)
		{
			comVec.erase(iter);
			return;
		}
	}
}

//获得特定位置的组件
Component * Composite::GetChild(int index)
{
	return comVec[index];
}

Leaf.h（具体组件、实现组件操作）

#pragma once
#include "Component.h"

class Leaf:public Component
{
public:
	Leaf();
	~Leaf();

	void Operation();
};

Leaf.cpp

#include "Leaf.h"
#include <iostream>
using namespace std;

Leaf::Leaf()
{
}


Leaf::~Leaf()
{
}

void Leaf::Operation()
{
	cout << "Leaf Operation...." << endl;
}

main.cpp

#include "Component.h"
#include "Composite.h"
#include "Leaf.h"

int main(int argc, char* argv[])
{
	/*复合模式
	为递归构建树状的组合结构提供了很好的解决方案*/
	Leaf* I = new Leaf();
	I->Operation();
	Composite* com = new Composite();
	com->Add(I);
	com->Operation();
	Component* II = com->GetChild(0);
	II->Operation();
	

	system("pause");
	return 0;
}

Leaf Operation....
Leaf Operation....
Leaf Operation....
请按任意键继续. . .

Composite 模式（复合模式）主要提供了一种递归构建树状的组合结构的方法
Composite 模式和 Decorator 模式的类图比较相似，他们的区别在于Decorator 模式仅仅为对象添加新的职责，并不涉及对象的构建和管理。