C++设计模式大全，23种设计模式合集详解—👉（点我跳转）

一、设计流程探讨

  如果应用的核心模型能用树状结构表示，在应用中使用组合模式才有价值。
  例如，你有两类对象产品和盒子。一个盒子中可以包含多个产品或者几个较小的盒子 。这些小盒子中同样可以包含一些产品或更小的盒子，以此类推。
  假设你希望在这些类的基础上开发一个定购系统。订单中可以包含无包装的简单产品，也可以包含装满产品的盒子……以及其他盒子。此时你会如何计算每张订单的总价格呢？

  你可以尝试直接计算：打开所有盒子，找到每件产品，然后计算总价。这在真实世界中或许可行，但在程序中，你并不能简单地使用循环语句来完成该工作。你必须事先知道所有产品和盒子的类别，所有盒子的嵌套层数以及其他繁杂的细节信息。因此，直接计算极不方便，甚至完全不可行。
解决方案：
  组合模式建议使用一个通用接口来与产品和盒子进行交互，并且在该接口中声明一个计算总价的方法。
  那么方法该如何设计呢？对于一个产品，该方法直接返回其价格；对于一个盒子，该方法遍历盒子中的所有项目，询问每个项目的价格，然后返回该盒子的总价格。如果其中某个项目是小一号的盒子，那么当前盒子也会遍历其中的所有项目，以此类推，直到计算出所有内部组成部分的价格。你甚至可以在盒子的最终价格中增加额外费用，作为该盒子的包装费用。

  该方式的最大优点在于你无需了解构成树状结构的对象的具体类。你也无需了解对象是简单的产品还是复杂的盒子。你只需调用通用接口以相同的方式对其进行处理即可。当你调用该方法后，对象会将请求沿着树结构传递下去。
 
真实世界类比：

  大部分国家的军队都采用层次结构管理。每支部队包括几个师，师由旅构成，旅由团构成，团可以继续划分为排。最后，每个排由一小队实实在在的士兵组成。军事命令由最高层下达，通过每个层级传递，直到每位士兵都知道自己应该服从的命令。

二、模式介绍

（1）模式动机
  在软件在某些情况下，客户代码过多地依赖于对象容器复杂的内部实现结构，对象容器内部实现结构(而非抽象接口)的变化将引起客户代码的频繁变化，带来了代码的维护性、扩展性等弊端。
  如何将 “客户代码与复杂的对象容器结构” 解耦，让对象容器自己来实现自身的复杂结构，从而使得客户代码就像处理简单对象一样来处理复杂的对象容器?
（2）模式定义
  将对象组合成树形结构以表示 “部分-整体” 的层次结构，Composite使得用户对单个对象和组合对象的使用具有一致性(稳定)。
（3）要点总结
 a). Composite模式采用树形结构来实现普遍存在的对象容器，从而将 “一对多” 的关系转化为 “一对一” 的关系，使得客户代码可以一致地(复用)处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。
 b). 将 “客户代码与复杂的对象容器结构” 解耦是Composite的核心思，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的内部实现结构——发生依赖，从而更能“应对变化”。
 c). Composite模式在具体实现中，可以让父对象中的子对象反向追溯。如果父对象有频繁的遍历需求，可使用缓存技巧来改善效率。

三、代码实现

  下面是使用组合模式的伪代码，对象形成了个树结构。如果我们不采用树结构，即取消掉for (auto &e : elements)，则我们需要在void Invoke()中按类型分别写process的方法(需要把类内部的数据结构刨出来，然后针对性的处理)。所以我们在做for (auto &e : elements)把访问方法封装进去了类内部，而没有暴露出来。

class Component{
public:
	virtual void process() = 0;
	virtual ~Component(){}
};
//树节点
class Composite : public Component{
	string name;
	list<Component*> elements;
public:
	Composite(const string &s) : name(s){}
	void add(Component* element){
		elements.push_back(element);
	}
	void remove(Component* element){
		elements.remove(element);
	}
	void process() override {
		//...   先处理当前节点
		//再处理叶子节点
		for (auto &e : elements)
			e->process();		  //这是多态的调用，进行下去相当于递归
	}
};
//叶子节点
class Leaf : public Component{
	string name;
public:
	Leaf(string s) : name(s) {}
	void process() override {
		//process current node
	}
};
void Invoke(Component &c){
	//...
	c.process();	//多态调用
	//...
}
int main(){
	Composite root("root");
	Composite treeNode1("treeNode1");
	Composite treeNode2("treeNode2");
	Composite treeNode3("treeNode3");
	Composite treeNode4("treeNode4");
	Leaf leaf1("left1");
	Leaf leaf1("left2");

	root.add(&treeNode1);
	treeNode1.add(&treeNode2);
	treeNode2.add(&leaf1);

	root.add(&treeNode3);
	treeNode3.add(&treeNode4);
	treeNode4.add(&leaf2);

	process(root);	//此时则会按上面我们构成的树结构从root开始进行process的顺序处理
	process(treeNode3);	 //从treeNode3开始按树结构往下处理
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58