9、组合模式（结构性模式）

组合模式又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构，以一致的方式处理叶子对象以及组合对象，不以层次高低定义类，都是结点类

一、传统组合模式

举例，大学、学院、系，它们之间不是继承关系，是组合关系：大学由学院组成，学院由系组成，但是它们都是组织结点，一个大学，n个学院，一个学院m个系，大学、学院是 组合类型的，它们都包含结点成员，系是 叶子类型 的，不包含结点成员

把大学类、学院类、系类抽象为组织结点类，它们都是组织结点类的子类（其中大学子类、学院子类是组合类型的类，系是叶子类型的类），按照具体依赖抽象原则，以子类共有的属性和行为来定义结点类，代码如下：

//组织结点（基类）Organization
class Organization{                      //具体依赖抽象原则
	std::string name;//数据成员
public:
	Organization( std::string name):name(name) { }//构造函数
	virtual ~Organization(){ }                    //虚析构
	//其他成员函数
    virtual std::string getName(){ return name; }   
    virtual void add(Organization* o){ throw "叶子结点没有成员!\n"; }
    //virtual void remove( ){ throw "叶子结点没有成员!\n";  }
    virtual void print() = 0;  //
};

组合类型的子类University、College，重写基类成员函数，代码几乎一样

//组合类型（子类）University College
//University
class University:public Organization{
	std::list<Organization*> ul; //以基类的形式包含其他子类对象
public:
	University(std::string name):Organization(name) { }
	~University(){
		std:: cout << "~University\n";
		for(auto o:ul){ delete o; }		
	}
	//重写
	virtual void add(Organization* o){
		ul.push_back(o);
	}
    virtual void print(){
		std::cout << getName() << "\n";//基类成员获取，基类的成员也是子类的组成部分
		for( auto o:ul ){
			o->print();
		}
	}	
};

//College
class College:public Organization{
	std::list<Organization*> cl; //以基类的形式包含其他子类对象
public:
	College(std::string name):Organization(name) { }
	~College(){
		std:: cout << "~College\n";
		for(auto o:cl){ delete o; }		
	}
	//重写
	virtual void add(Organization* o){
		cl.push_back(o);
	}
    virtual void print(){
		std::cout << getName() << "\n";//基类成员获取，基类的成员也是子类的组成部分
		for( auto o:cl ){
			o->print();
		}
	}	
};

叶子类型的子类（Department）

//叶子类型（子类）Department
class Department:public Organization{
public:
	Department(std::string name):Organization(name) { }
	~Department(){
		std:: cout << "~Department\n";
	}
	//重写
	virtual void print(){
		std::cout << getName() << "\n";
	}
};

头文件及测试代码

#include <iostream>
#include <string>
#include <exception>
#include <list>

int main() 
{
	University u("清华大学");
	Organization* c1 = new College("计算机学院");
	Organization* c2 = new College("信息工程学院");
	Organization* d = new Department("信息工程");
	u.add( c1 );
	u.add( c2 );
	c2->add( d );
	u.print();
	//c2->print();	
    return 0;
}

二、组合模式的结点设计

把组合类型的的属性、行为都放到结点，以对象组是否为空来判断是叶子类型的还是组合类型的，这样叶子类型也可以扩展为组合类型，虽然看起来有点混乱，但是确实可行，比如系原来是叶子，现在有了个学生会，添加成员后就可以不是叶子了

#include <iostream>
#include <string>
#include <exception>
#include <list>
 
//组织结点（基类）Organization
class Organization{  //具体依赖抽象原则
	std::string name;//数据成员
	std::list<Organization*> ol; //对象组
public:
	Organization( std::string name):name(name) { } //构造函数
	virtual ~Organization(){	 //虚析构
		for(auto o:ol){ delete o; }	
	}                    
	//其他成员函数 
    virtual void add(Organization* o){ ol.push_back(o); }	
    virtual void print(){
		std::cout << name << "\n";
		if( !ol.empty() ) //判断是否是叶子结点
		{ 
			for( auto o:ol ){
				o->print();
			}
		}	
	}
};    
 
//University
class University:public Organization{
public:
	University(std::string name):Organization(name) { }
	~University(){ std:: cout << "~University\n"; }
};
 
//College
class College:public Organization{
	std::list<Organization*> cl; //以基类的形式包含其他子类对象
public:
	College(std::string name):Organization(name) { }
	~College(){
		std:: cout << "~College\n";
	}
};
 
//Department
class Department:public Organization{
public:
	Department(std::string name):Organization(name) { }
	~Department(){
		std:: cout << "~Department\n";
	}
};
 
//StudentUnion
class StudentUnion:public Organization{
public:
	StudentUnion(std::string name):Organization(name) { }
	~StudentUnion(){
		std:: cout << "~StudentUnion\n";
	}
};
 
int main() 
{
	University u("清华大学");
	Organization* c1 = new College("计算机学院");
	Organization* c2 = new College("信息工程学院");
	Organization* d1 = new Department("信息工程");
	Organization* d2 = new Department("软件工程");
	Organization* s = new StudentUnion("信息工程学生会");
	
	d1->add( s );
	c1->add( d2 );
	c2->add( d1 );
	
	u.add( c1 );
	u.add( c2 );
	
	u.print( );
	//c2->print( );	
    return 0;
}

三、修改打印函数，打印出树形结构

1、修改print

    virtual void print( int depth ){
		for(int i=0; i< depth; ++i)
			std:: cout << "--";
		std::cout << name << "\n";
		if( !ol.empty() ) //判断是否是叶子结点
		{ 
			for( auto o:ol ){
				o->print(depth+1);
			}
		}	
	}

2、调用修改为