设计模式观后（c++还原之十八 组合模式）

//组合模式
//作者这个模式举得例子很有趣：树、根、叶；
//用上面的思想要把员工管理组合在一起。
//经理添加员工，获取信息。组长添加员工，获取信息等，树结构。
//抽象员工接口、（根节点）
class ICorp {
public:
	virtual string GetInfo() = 0;
	virtual int GetType() {return 0;}//获取职位类型0：树叶 1：树枝
	virtual string IntToChar(int a) {  
		char buffer[10] = {0};  
		_itoa_s(a, buffer, 10, 10);  
		string temp(buffer);  
		return temp;  
	}  
};
//树叶接口(组长接口)
class Leaf : public ICorp {
private:
	string m_strName;
	string m_strPosition;//职位
	int m_nSalary;
public:
	Leaf(string name, string position, int salary) {
		m_strName = name;
		m_strPosition = position;
		m_nSalary = salary;
	}
	string GetInfo() {
		string info;
		info += "姓名：" +m_strName;
		info += "\n职位：" + m_strPosition;
		info += "\n薪水" + IntToChar(m_nSalary);
		info += "\n";
		return info;
	}
};
//树枝接口（抽象经理类）
class IBranch : public ICorp {
public:
	//添加成员（小兵或经理）
	virtual void AddSubordinate(ICorp* corp) = 0;
	virtual int GetType() {return 1;}
	//获取下属信息
	virtual deque<ICorp*>* GetSubordinate() = 0;
};
//树枝实现
class Branch : public IBranch {
private:
	string m_strName;
	string m_strPosition;//职位
	int m_nSalary;
	deque<ICorp*>* m_pDICorp;
public:
	Branch(string name, string positon, int salary)
		: m_pDICorp(new deque<ICorp*>) {
		m_strName = name;
		m_strPosition = positon;
		m_nSalary = salary;
	}
	void AddSubordinate(ICorp* corp) {
		m_pDICorp->push_back(corp);
	}
	deque<ICorp*>* GetSubordinate() {
		return m_pDICorp;
	}
	string GetInfo() {
		string info;
		info += "姓名：" +m_strName;
		info += "\n职位：" + m_strPosition;
		info += "\n薪水" + IntToChar(m_nSalary);
		info += "\n";
		return info;
	}
};

class Client {
public:
	static Branch* CompositeCorpTree() {
		//先产生根，总经理
		Branch* root = new Branch("王大", "总经理", 100000);
		//产生部门经理
		Branch* develop = new Branch("刘瘸", "研发部经理", 1000);
		Branch* sales	= new Branch("马二", "销售经理", 2000);
		Branch* finance = new Branch("赵三", "财务经理", 3000);
		//产生三个组长
		Branch* first	= new Branch("杨三", "开发一组", 5000);
		Branch* second	= new Branch("吴大", "开发二组", 6000);
		//产生所有小兵
		Leaf* a = new Leaf("a", "码农", 2000);
		Leaf* b = new Leaf("b", "码农", 2000);
		Leaf* c = new Leaf("c", "秘书", 2000);
		Leaf* d = new Leaf("d", "财务", 2000);
		Leaf* e = new Leaf("e", "销售", 2000);

		//开始组装
		root->AddSubordinate(c);
		root->AddSubordinate(develop);
		root->AddSubordinate(sales);
		root->AddSubordinate(finance);
		//研发经理
		develop->AddSubordinate(first);
		develop->AddSubordinate(second);
		//小组成员
		first->AddSubordinate(a);
		second->AddSubordinate(b);
		//看销售
		sales->AddSubordinate(e);
		//看财务
		finance->AddSubordinate(d);

		return root;
	}
	static string GetTreeInfo(Branch* root) {
		deque<ICorp*>* p_ICorp = root->GetSubordinate();
		string info;
		for (deque<ICorp*>::iterator i = p_ICorp->begin();
			i != p_ICorp->end(); i++)
		{
			if ((*i)->GetType() == 1) {
				string temp;
				temp = (*i)->GetInfo() + "\n";
				info += temp + GetTreeInfo((Branch*)(*i));
			} else {
				info += (*i)->GetInfo() + "\n";
			}
		}
		return info;
	}

	static void main() {
		Branch* ceo = CompositeCorpTree();
		cout << ceo->GetInfo();
		cout << GetTreeInfo(ceo);
	}
};
//这个设计用递归应该是最好的方法了吧！
//递归遍历
//组合模式在于高层模块调用简单
//节点自由添加
//开始有点像stl的迭代器设计了
int _tmain(int argc, _TCHAR* argv[])
{
	Client::main();
	system("pause");
	return 0;
}