设计模式：composite组合模式

属于数据结构模式的一种，常常有一些组件再内部具有特定的数据结构，如果客户程序依赖这些数据结构，那么将极大的破坏组件的服用。我们需要将这些特定的数据结构封装在内部，再外部提供统一的接口，来实现与特定数据结构无关的访问。就是将客户代码与复杂的对象容器结构解耦合。
composite模式将对象组合成部分-总体的层次结构，对一对一，一对多统一视为一对一，使得用户对单个对象和组合对象的使用具有一致性。用户无需关心处理的是单个的对象，还是组合的对象容器。
使用了composite后，用户将与抽象接口发生依赖，而不是与具体类里面的复杂数据结构发生依赖。
以目录和文件的关系来说比较好理解，文件目录关系就是一个树状图，包括root节点在内，每个目录中既可能还有目录，也可能含有文件。composite模式为访问目录和访问文件提供的是一个统一的接口。

在游戏开发中，我们在同一个界面中会使用很多不同的视图，比如赛车游戏，视图有：小地图，速度表盘，显示角色等，想要为每个视图提供一个统一的访问点，即相同的函数调用应该既能够访问主视图也能够访问子视图。这种统一的接入点可以使用组合设计模式。

ps：其实我觉的这种结构挺像装饰器模式的。。。

#pragma once
#include <iostream>
#include <list>
using namespace std;

template<typename T>
class Component {
public:
	virtual void add() {}
	virtual void remove() {}
	virtual void show_child_or_self() {}
	virtual ~Component() {}
};

template<typename T>
class Composite :public Component<T> {
private:
	list<Component<T>*>My_child;
public:
	string name;
	Composite(string name) :name(name) {}
	virtual void add(Component<T>* com) {
		My_child.push_back(com);
	}
	virtual void remove(Component<T>* com) {
		My_child.remove(com);
	}
	virtual void show_child_or_self() {
		for (Component<T>* i : My_child) {
			i->show_child_or_self();
		}
	}
};

template<typename T>
class leaf :public Component<T> {
public:
	string name;
	leaf(string name) :name(name) {}
	virtual void show_child_or_self() {
		cout << "我是一个叶子,我的名字是" <<name << endl;
	}
};

测试接口

	//测试composite模式
	cout << "测试composite模式" << endl;
	auto root = new Composite<bool>("root");
	auto tree_node_1 = new Composite<bool>("node_1");
	auto tree_node_2 = new Composite<bool>("node_2");
	auto tree_leaf_1 = new leaf<bool>("leaf_1");
	auto tree_leaf_2 = new leaf<bool>("leaf_2");
	auto tree_leaf_3 = new leaf<bool>("leaf_3");
	root->add(tree_leaf_1);
	root->add(tree_node_1);
	tree_node_1->add(tree_leaf_2);
	tree_node_1->add(tree_node_2);
	tree_node_2->add(tree_leaf_3);
	root->show_child_or_self();
	cout << endl;