composite(组合）模式

Composite模式定义:
将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，使得客户端对单个对象和组合对象的使用具有一致性.

 Composite比较容易理解，想到Composite就应该想到树形结构图。组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。

所以Composite模式使用到Iterator模式，和Chain of Responsibility模式类似。

Composite好处:
1.使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。

如何使用Composite
首先定义一个接口或抽象类，这是设计模式通用方式了，其他设计模式对接口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和管理Composite组合体的对象们（或称部件Component）

首先看一下Composite的结构

理解

1.        Component 是组合对象的基类，定义了类的公共方法；提供一个访问和管理子组件的方法。

管理子组件的方法：Add- 添加子组件；Remove- 移除子组件；GetChild- 遍历获取组建对象的指针。

Operation 是需要子组件具体定义的公共接口。

2.        Leaf 是组合对象的叶子节点（树叶）。叶子节点没有子组件（也就没有管理子组件的方法），只有公共行为方法Operation 。

3.        Composite 是具体的子组件类（树枝）。实现基类接口。它可以继续派生子组件或者叶子节点。

代码如下：

//Component.h
#ifndef _COMPONENT_H_
#define _COMPONENT_H_
class Component
{
public:
Component();
~Component();
virtual void operation() = 0;
protected:

void add(const Component& );


void remove(const Component&);
virtual Component* getChildByID(int );
};

   #endif

//Component.cpp
#include "Component.h"
Component::Component()
{


}
Component::~Component()
{


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


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


}
Component* Component::getChildByID(int)
{
return 0;
}

//Composite.h
#ifndef _COMPOSITE_H_
#define _COMPOSITE_H_
#include "Component.h"
#include "vector"
using namespace std;
class Composite :public Component
{
public:
Composite();
~Composite();
void add(Component* com);
void remove(Component* com);
void operation();
Component* getChildByID(int index);
protected:
vector<Component*>ComVer;
};
#endif

//Composire.cpp
#include "Composite.h"
#include "Component.h"
#include "algorithm"
#include "iostream"
Composite::Composite()
{
   
}
Composite::~Composite()
{


}
void Composite::add(Component* com)
{
cout<<"add com......"<<endl;
ComVer.push_back(com);
}
void Composite::remove(Component* com)
{
cout<< "remove com....."<<endl;
vector<Component*>::iterator iter = find(ComVer.begin(),ComVer.end(),com);
if(iter != ComVer.end())
ComVer.erase(iter);
}
Component * Composite::getChildByID(int index)
{
cout<<"getChildByID index......"<<endl;
return ComVer[index];
}
void Composite::operation()
{
vector<Component*>::iterator iter = ComVer.begin();
for(;iter != ComVer.end(); iter++)
{
(*iter)->operation();
}
}

//Leaf.h
#ifndef _LEAF_H_
#define _LEAF_H_
#include "Component.h"
class Leaf : public Component
{
public:
Leaf();
~Leaf();
    void operation();


};
#endif

//Leaf.cpp
#include "Leaf.h"
#include "iostream"
using namespace std;
Leaf::Leaf()
{


}
Leaf::~Leaf()
{


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

// main.cpp
#include "Leaf.h"
#include "Component.h"
#include "Composite.h"
#include "iostream"
using namespace std;
void main()
{
Component* leaf_1 = new Leaf();
leaf_1->operation();


Component* leaf_2 = new Leaf();
leaf_2->operation();
Composite* com = new Composite();
com->add(leaf_1);
com->add(leaf_2);
com->operation();
com->remove(leaf_1);
com->operation();




}

显示结果：