C++设计模式08.组合模式
### 组合#### 多个属性
组合设计模式通常适用于整个类，一个对象通常由多个对象构成。举个例子，方便理解。在一个游戏中，每个生物都有不同的强度值、敏捷值、智力值等，这就很容易定义：
```c++
class Creature{
int strength, agility, intelligence;
public:
int get_strength() const
{
return strength;
}
void set_strength(int strength){
Creature::strength = strength;
}
int get_agility() const
{
return agility;
}
void set_agility(int agility){
Creature::agility = agility;
}
int get_intelligence() const
{
return intelligence;
}
void set_intelligence(int intelligence){
Creature::intelligence = intelligence;
}
};
```
接下来我们想要对这些属性进行操作，例如求多个属性的最大值、平均值、总和,如下:
```c++
class Creature{
//其他的数据成员
int sum() const{
return strength + agility + intelligence;
}
double average const{
return sum() / 3.0;
}
int max() const{
return ::max(::max(strength, agility),intelligence);
}
}
```
然而这样并不理想，原因如下：
1）在计算所有统计数据总和时候，我们容易犯错并且忘记其中一个
2）3.0是代表属性的数目，在这里被设计成一个固定值
3）计算最大值时，我们必须构建一对std::max()
想象一下如果再增加一个新的属性，这个时候我们需要对sum()，average()，max()重构，这是十分糟糕的。
如何避免？如下：
```c++
class Creature{
enum Abilities {str, agl, intl, count};
array<int,count> abilities;
}
```
上面的枚举定义了一个名为count的额外值，标记着有多少个属性。现在我们这样定义属性的get和set方法：
```c++
int get_strength() const { return abilities;}
void set_strength(int value){
abilities=value;
}
//对于其他属性同样
```
现在再让我们看看对sum()，average()，max()的计算，看看有什么改进:
```c++
int sum() const{
return accumulate(abilities.begin(), abilities.end(),0);
}
double average() const{
return sum() / (double)count;
}
int max() const{
return *max_element(abilities.begin(), abilities.end());
}
```
是不是更棒了，不仅使代码更容易编写和维护，而且添加新属性时候，十分简单，总量根本不需要去改变，并不会影响sum()，average()，max()。
#### 组合图形对象
想想诸如PowerPoint等应用程序，在哪里您可以选择多个不同的对象并将其作为一个拖动。然而如果要选一个一个对象，您也可以抓取该对象。渲染也是相同的：您可以呈现单个图形对象，或者您可以将多个形状组合在一起，并将其绘制为一个组。这种方法的实现相当容易，因为它只是依赖于单个接口，如下所示：
```c++
struct GraphicObject{
virtual void draw() = 0;
};
```
现在从名字来看，你可能认为它总是代表一个单独的项目。然而，想想看：几个矩形和圆形组合在一起代表一个组合图形对象。正如我可以定义的，比如说，一个圆：
```c++
struct Circle : GraphicObject
{
void draw() override
{
std::cout << "Circle" << std::endl;
}
};
```
同样，我们可以定义一个由几个其他图形对象组成的图形对象。是的，关系可以无限递归：
```c++
struct Group : GraphicObject
{
std::string name;
explicit Group(const std::string& name) : name(name){}
void draw() override
{
std::cout << "Group" << name.c_str() << " contains:" << std::endl;
for(auto&& o:obejct)
o->draw();
}
std::vector<GraphicObject*> objects;
}
```
单个圆和任意组都可以绘制，只要他们实现了draw()函数。组中有一个指向其他图形对象的指针数组，通过其访问多个对象的draw()方法，来渲染自身。
以下是编程接口的使用方法：
```c++
Group root("root");
Circle c1, c2;
root.obejects.push_back(&c1);
Group subgroup("sub");
subgroup.objects.push_back(&c2);
root.obejcts.push_back(&subgroup);
root.draw();
```
前面的代码生成以下输出：
```c++
Group root contains:
Circle
Group sub contains:
Circle
```
这是组合设计模式最简单的实现，尽管我们自己已经定义了一个定制接口。现在，如果我们尝试采用其他一些更标准化的迭代对象的方法，这个模式会是什么样子呢？
#### 神经网络
机器学习是热门的新事物。机器学习中的一部分是使用人工神经网络:试图模仿神经元在我们大脑中工作方式的软件结构。
神经网络的核心概念当然是神经元。神经元可以根据其输入产生(通常是数字)输出，我们可以将该值反馈给网络中的其他连接。我们将只关注连接，所以我们将这样对神经元建模:
```c++
1 struct Neuron
2 {
3 vector<Neuron*> in, out;
4 unsigned int id;
5
6 Neuron()
7 {
8 static int id = 1;
9 this->id = id++;
10 }
11 };
```
我在id字段输入了身份。现在，你可能想做的是把一个神经元连接到另一个神经元上，这可以用
```c++
1 template<> void connect_to<Neuron>(Neuron& other)
2 {
3 out.push_back(&other);
4 other.in.push_back(this);
5 }
```
这个函数造当前神经元和另一个神经元之间建立了联系。目前为止，一切顺利。现在，假设我们也想创建神经元层。一个层很简单，就是特定数量的神经元组合再一起。
```c++
1 struct NeuronLayer : vector<Neuron>
2 {
3 NeuronLayer(int count)
4 {
5 while (count --> 0)
6 emplace_back(Neuron{});
7 }
8 };
```
看起来不错。但是现在有一个小问题。问题是这样的：我们希望神经元能够连接到神经元层。总的来说，我们希望像这样能够奏效：
```c++
1 Neuron n1, n2;
2 NeuronLayer layer1, layer2;
3 n1.connect_to(n2);
4 n1.connect_to(layer1);
5 layer1.connect_to(n1);
6 layer1.connect_to(layer2);
```
如您所见，我们有四个不同的案例需要处理:
1、神经元连接到另一个神经元
2、神经元连接到神经元层
3、神经元层连接到神经元
4、神经元层连接到另一个神经元层
正如你所猜到的，我们不可能对connect_to()函数进行四次重载。如果有三个不同的类，你会考虑创建九个函数吗？我不这么认为。相反，我们要做的是在基类中插入槽。由于多重继承，我们完全可以做到这一点。那么，下面呢？
```c++
1 template <typename Self>
2 struct SomeNeurons
3 {
4 template <typename T> void connect_to(T&other)
5 {
6 for (Neuron& from : *static_cast<Self*>(this))
7 {
8 for (Neuron& to : other)
9 {
10 from.out.push_back(&to);
11 to.in.push_back(&from);
12 }
13 }
14 }
15 };
```
connect_to的实现绝对值得探讨。如您所见，它是一个模板成员函数，接受T，然后成对地迭代*this和T&的神经元，互相连接每个。但是有一个警告，我们不能只迭代*this，因为这会给我们一个SomeNeurons&和我们真正要找的类型。
这就是我们为什么被迫让一些神经元成为一个模板类，其中模板参数Self指的是继承类。然后我们在取消引用和迭代内容之前，将this指针转换为Self*。SomeNeurons<Neuron>是为了实现方便而付出的小小代价。
剩下的就是在Neuron和NeuronLayer中实现SomeNeurons::begin()和end()，让基于范围的循环真正工作。
由于NeuronLayer继承自vector，因此不用显示实现begin()/end()，它已经自动存在。但是神经元本身确实需要一种迭代的方法。它需要让自己成为唯一可重复的元素。这可以通过以下方式完成：
```c++
1 Neuron* begin() override { return this; }
2 Neuron* end() override { return this + 1; }
```
正是这个神奇的东西让SomeNeurons::connect_to()成为可能。简单来说，我们使得单个对象的行为像一个可迭代的对象集合。这允许以下所有用途：
```c++
1 Neuron neuron, neuron2;
2 NeuronLayer layer, layer2;
3
4 neuron.connect_to(neuron2);
5 neuron.connect_to(layer);
6 layer.connect_to(neuron);
7 layer.connect_to(layer2);
```
更不用说，如果您要引入一个新的容器（比如NeuronsRing），您所要做的就是从SomeNeurons<NeuronRing>继承，实现begin()/end()，新的类将立即连接到所有的神经元和神经元层。
#### 总结
复合设计模式允许我们为单个对象和对象集合提供相同的接口。这可以通过显式使用接口成员来完成，也可以通过duck typing（在程序设计中是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由"当前方法和属性的集合"决定）来完成。例如基于范围的for循环并不需要您继承任何东西，而是通过实现begin()和end()。
正是这些begin()/end()成员允许标量类型伪装成“集合”。同样有趣的是，我们的connect_to()函数的嵌套for循环能够将这两个构造连接在一起，尽管它们具有不同的迭代器类型:Neuron返回Neuron*而NeuronLayer返回vector::iterator——这两者并不完全相同。哈哈，这就是模板的魅力。
最后，我必须承认，只有当你想拥有一个单一成员函数时，所有这些跳跃才有必要。如果您可以调用一个全局函数，或者如果您对有多个connect_to()实现感到满意，那么基类SomeNeurons并不是必要的。
页:
[1]