设计模式-结构型-组成

#pragma once

#include <list> 
// 组合中的抽象基类 
class Component 
{ 
public: 
  Component(){} 
  virtual ~Component(){} 

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

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

// 派生自Component,是其中的叶子组件的基类 
class Leaf : public Component 
{ 
public: 
  Leaf(){} 
  virtual ~Leaf(){} 
  virtual void Operation(); 
}; 

// 派生自Component,是其中的含有子件的组件的基类 
class Composite : public Component 
{ 
public: 
  Composite(){} 
  virtual ~Composite(); 
  virtual void Operation(); 
  virtual void Add(Component* pChild); 
  virtual void Remove(Component* pChild); 
  virtual Component* GetChild(int nIndex); 
private: 
  // 采用list 容器去保存子组件 
  std::list<Component*> m_ListOfComponent; 
};

#include "StdAfx.h"
#include "composite_impl.h"

#include <iostream> 

#include <algorithm> 

/*--------------------- 
Component 成员函数的实现 
---------------------*/ 
void Component::Add(Component* pChild) 
{ 
} 

void Component::Remove(Component* pChild) 
{ 
} 

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

/*--------------------- 
Leaf 成员函数的实现 
---------------------*/ 
void Leaf::Operation() 
{ 
  std::cout << "Operation by leaf "<<this<<std::endl; 
} 

/*--------------------- 
Composite 成员函数的实现 
---------------------*/ 
Composite::~Composite() 
{ 
  for (std::list<Component*>::iterator iter  = m_ListOfComponent.begin();
    iter != m_ListOfComponent.end(); ++iter) 
  {
    delete *iter;
  } 
} 

void Composite::Add(Component* pChild) 
{ 
  m_ListOfComponent.push_back(pChild); 
} 

void Composite::Remove(Component* pChild) 
{ 
  std::list<Component*>::iterator iter = find(m_ListOfComponent.begin(), m_ListOfComponent.end(), pChild); 
  if (m_ListOfComponent.end() != iter) 
  { 
    m_ListOfComponent.erase(iter); 
  } 
} 

Component* Composite::GetChild(int nIndex) 
{ 
  if (nIndex <= 0 || nIndex > m_ListOfComponent.size()) 
    return NULL; 
  Component *pTmp = NULL;
  int index = 1;
  for (std::list<Component*>::iterator iter  = m_ListOfComponent.begin();
    iter != m_ListOfComponent.end(); ++iter,++index) 
  { 
    if (index == nIndex)
    {
      pTmp = *iter;
      break;
    }
  } 
  return pTmp; 
} 

void Composite::Operation() 
{ 
  std::cout << "Operation by Composite "<<this<<std::endl; 
  std::list<Component*>::iterator iter1, iter2; 
  for (iter1  = m_ListOfComponent.begin(), iter2 = m_ListOfComponent.end(); iter1 != iter2; ++iter1) 
  { 
    (*iter1)->Operation(); 
  }
}

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

#include "stdafx.h"

#include "composite_impl.h"
#include <stdlib.h>
#include <iostream>

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

int _tmain(int argc, _TCHAR* argv[])
{
  Leaf *pLeaf1 = new Leaf(); 
  Leaf *pLeaf2 = new Leaf(); 

  Composite* pComposite = new Composite;
  std::cout<<"Add two Leaf"<<std::endl;
  pComposite->Add(pLeaf1); 
  pComposite->Add(pLeaf2); 

  pComposite->Operation(); 
  std::cout<<"GetChild(index = 2)"<<std::endl;
  pComposite->GetChild(2)->Operation(); 

  delete pComposite; 
  system("pause");

  return 0;
}