结构型模式のComposite模式

Composite组合模式
作用：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。

UML图如下：

在Component中声明所有用来管理子对象的方法，其中包括Add、Remove等，这样实现Component接口的所有子类都具备了Add和Remove。
这样做的好处就是叶节点和枝节点对于外界没有区别，它们具备 完全一致的行为 接口。
但问题也很明显，因为Leaf类本身不具备Add()、Remove()方法的 功能，所以实现它是没有意义的。

何时使用组合模式：
当你发现需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑用组合模式了。

基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。

用户不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合二写一些选择判断语句了。

组合模式让客户可以一致地使用组合结构和单个对象。

抽象基类:
1)Component:为组合中的对象声明接口，声明了类共有接口的缺省行为(如这里的Add,Remove,GetChild函数)，声明一个接口函数可以访问Component的子组件.

接口函数:
1)Component::Operatation:定义了各个组件共有的行为接口，由各个组件的具体实现.
2)Component::Add添加一个子组件
3)Component::Remove::删除一个子组件.
4)Component::GetChild:获得子组件的指针.

说明:
Component模式是为解决组件之间的递归组合提供了解决的办法，它主要分为两个派生类：

1)、Leaf是叶子结点,也就是不含有子组件的结点

2)、Composite是含有子组件的类.

举一个例子来说明这个模式，在UI的设计中,最基本的控件是诸如Button、Edit这样的控件，相当于是这里的Leaf组件，而比较复杂的控件 比如Panel则可也看做是由这些基本的组件组合起来的控件，相当于这里的Composite，它们之间有一些行为含义是相同的，比如在控件上作一个点 击,移动操作等等的，这些都可以定义为抽象基类中的接口虚函数，由各个派生类去实现之，这些都会有的行为就是这里的Operation函数，而添加、删除 等进行组件组合的操作只有非叶子结点才可能有，所以虚拟基类中只是提供接口而且默认的实现是什么都不做。

代码如下：

//Component.h

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

　//纯虚函数，只提供接口，没有默认的实现
    virtual void Operator() = 0;

　// 虚函数,提供接口,有默认的实现就是什么都不做
    virtual void Add(Component*);
    virtual void Remove(Component*);
    virtual Component* GetChild(int index);
protected:
    Component(void);
};

//Component.cpp

#include "StdAfx.h"
#include "Component.h"
#include <iostream>
using std::endl;
using std::cout;

Component::Component(void)
{
}


Component::~Component(void)
{
}

void Component::Add(Component* com){
    
}

void Component::Remove(Component* com){

}

void Component::Operator(){
    
}

Component* Component::GetChild(int index){
    return NULL;
}

//leaf.h

#pragma once
#include "component.h"
class Leaf :
    public Component
{
public:
    Leaf(void);
    virtual ~Leaf(void);
    virtual void Operator();
};

//leaf.cpp

#include "StdAfx.h"
#include "Leaf.h"
#include <iostream>
using std::cout;
using std::endl;

Leaf::Leaf(void)
{
}


Leaf::~Leaf(void)
{
}

void Leaf::Operator(){
    cout<<"Leaf::operator"<<endl;
}

//Composite.h

#pragma once
#include "component.h"
#include <vector>
using std::vector;
class Composite :
    public Component
{
public:
    Composite(void);
    virtual ~Composite(void);
    void Operator();
    void Add(Component*);
    void Remove(Component*);
    Component* GetChild(int index);
private:
    vector<Component*> m_ComVec;
};

//Composite.cpp

#include "StdAfx.h"
#include "Composite.h"
#include <iostream>
#include <algorithm>
using std::endl;
using std::cout;

Composite::Composite(void)
{
}


Composite::~Composite(void)
{
}

void Composite::Add(Component* com){
    this->m_ComVec.push_back(com);
}

void Composite::Remove(Component* com){
    
    this->m_ComVec.erase(find(this->m_ComVec.begin(),this->m_ComVec.end(),com));
}

void Composite::Operator(){
    cout<<"Composite::Operator"<<endl;
    vector<Component*>::iterator iter = this->m_ComVec.begin();
    for(;iter != this->m_ComVec.end();iter++){
        (*iter)->Operator();
    }
}

Component* Composite::GetChild(int index){
    if(index<0 || index >(int)(this->m_ComVec.size()))
        return NULL;
    return this->m_ComVec[index];
}

// main.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"
#include "Leaf.h"
#include "Composite.h"

int _tmain(int argc, _TCHAR* argv[])
{
    Composite* pRoot = new Composite();
    pRoot->Add(new Leaf());

    Leaf* pLeaf1 = new Leaf();
    Leaf* pLeaf2 = new Leaf();
    
    pRoot->Add(pLeaf1);
    pRoot->Add(pLeaf2);
    pRoot->Remove(pLeaf1);

    pRoot->Operator();

    return 0;
}

 

 

组合的另一个例子：摘自~~~

　　DP书上给出的定义：将对象组合成树形结构以表示“部分-整体”的层次结构。组合使得用户对单个对象和组合对象的使用具有一致性。注意两个字“树形”。这 种树形结构在现实生活中随处可见，比如一个集团公司，它有一个母公司，下设很多家子公司。不管是母公司还是子公司，都有各自直属的财务部、人力资源部、销 售部等。对于母公司来说，不论是子公司，还是直属的财务部、人力资源部，都是它的部门。整个公司的部门拓扑图就是一个树形结构。

      下面给出组合模式的UML图。从图中可以看到，FinanceDepartment、HRDepartment两个类作为叶结点，因此没有定义添加函数。 而ConcreteCompany类可以作为中间结点，所以可以有添加函数。那么怎么添加呢？这个类中定义了一个链表，用来放添加的元素。

 

//Company.h

#pragma once
#include <string>
using std::string;
class Company
{
public:
    Company(string name);
    virtual ~Company(void);
    virtual void Add(Company* pCom);
    virtual void Show(int depth);
protected:
    string m_name;
};

//Company.cpp

#include "StdAfx.h"
#include "Company1.h"

Company1::Company1(string name)
{
    m_name=name;
}

Company1::~Company1(void)
{
}

void Company1::Add(Company1* pCom){
}

void Company1::Show(int depth){
}

//ConcreteCompany.h

#pragma once
#include "company.h"
#include <list>
using std::list;
class ConcreteCompany :
    public Company
{
public:
    ConcreteCompany(string name);
    virtual ~ConcreteCompany(void);
    void Add(Company* pCom);
    void Show(int depth);
private:
    list<Company *> m_listCompany;
};

//ConcreteCompany.cpp

#include "StdAfx.h"
#include "ConcreteCompany.h"
#include <iostream>
using std::endl;
using std::cout;

ConcreteCompany::ConcreteCompany(string name):Company(name)
{
}


ConcreteCompany::~ConcreteCompany(void)
{
}

void ConcreteCompany::Add(Company* pCom){
    m_listCompany.push_back(pCom);
}

void ConcreteCompany::Show(int depth){
    for(int i = 0;i<depth;i++)
        cout<<"-";
    cout<<this->m_name<<endl;
    list<Company*>::iterator iter=m_listCompany.begin();
    for(;iter!=m_listCompany.end();iter++)
        (*iter)->Show(depth+2);
}

//FinanceDepartment.h

#pragma once
#include "company.h"
class FinanceDepartment :
    public Company
{
public:
    FinanceDepartment(string name);
    virtual ~FinanceDepartment(void);
    virtual void Show(int depth);
};


//FinanceDepartment.cpp

#include "StdAfx.h"
#include "FinanceDepartment.h"
#include <iostream>
using std::endl;
using std::cout;

FinanceDepartment::FinanceDepartment(string name):Company1(name)
{
}


FinanceDepartment::~FinanceDepartment(void)
{
}

void FinanceDepartment::Show(int depth){
    for(int i=0;i<depth;i++)
        cout<<"-";
    cout<<this->m_name<<endl;
}

//HRDepartment.h

#pragma once
#include "company.h"
class HRDepartment :
    public Company
{
public:
    HRDepartment(string name);
    virtual ~HRDepartment(void);
    virtual void Show(int depth);
};

//HRDepartment.cpp

#include "StdAfx.h"
#include "HRDepartment.h"
#include <iostream>
using std::endl;
using std::cout;

HRDepartment::HRDepartment(string name):Company(name)
{
}

HRDepartment::~HRDepartment(void)
{
}

void HRDepartment::Show(int depth){
    for(int i=0;i<depth;i++)
        cout<<"-";
    cout<<this->m_name<<endl;
}

// Company.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"
#include "ConcreteCompany.h"
#include "FinanceDepartment.h"
#include "HRDepartment.h"

int _tmain(int argc, _TCHAR* argv[])
{
    Company *root = new ConcreteCompany("总公司");
    Company *leaf1 = new FinanceDepartment("财务部");
    Company *leaf2 = new HRDepartment("人力资源部");
    root->Add(leaf1);
    root->Add(leaf2);

    Company1* mid1 = new ConcreteCompany("分公司A");
    Company1* leaf3 = new FinanceDepartment("财务部");
    Company1* leaf4 = new HRDepartment("人力资源部");
    mid1->Add(leaf3);
    mid1->Add(leaf4);
    root->Add(mid1);

    Company1 *mid2=new ConcreteCompany("分公司B");  
    FinanceDepartment *leaf5=new FinanceDepartment("财务部");  
    HRDepartment *leaf6=new HRDepartment("人力资源部");  
    mid2->Add(leaf5);  
    mid2->Add(leaf6);  
    root->Add(mid2);  
    root->Show(0);  

    delete leaf1; delete leaf2;  
    delete leaf3; delete leaf4;  
    delete leaf5; delete leaf6;   
    delete mid1; delete mid2;  
    delete root;  
    return 0;
}

 

测试环境：vs 2010

 

上面的实现方式有缺点，就是内存的释放不好，需要客户自己动手，非常不方便。有待改进，比较好的做法是让ConcreteCompany类来释放。因为所 有的指针都是存在ConcreteCompany类的链表中。C++的麻烦，没有垃圾回收机制。上面的实现方式有缺点，就是内存的释放不好，需要客户自己 动手，非常不方便。有待改进，比较好的做法是让ConcreteCompany类来释放。因为所有的指针都是存在ConcreteCompany类的链表 中。C++的麻烦，没有垃圾回收机制。

 

本文经过博主修改、原文参考：~~~