C++设计模式 - 组合模式详解

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

通俗一点就是，组合模式的设计整体就是一颗树形的数据结构。有根节点、树枝节点还由叶子节点。

举个例子 士兵出去打仗，比如说连长带着几个班，班长带着几个士兵，这个模式就是一个典型的树形结构组织。这个怎么实现呢？

首先抽象出一个士兵的基类。无论连长还是班长前提他们都是士兵提。

//士兵基类
class ISoldier {
public:
	ISoldier(std::string duty,std::string name,int age);
	~ISoldier();

	virtual void add(ISoldier* s);
	virtual void remove(ISoldier* s);

	virtual void setParent(ISoldier* p);
	virtual ISoldier* getParent();

	virtual void getSoldierInfo();
	virtual std::vector<ISoldier*> getSubSoldiers();
protected:
	std::string _duty;//职务
	std::string _name;//姓名
	int _age;//年龄
};

ISoldier::ISoldier(std::string duty, std::string name, int age):
_duty(duty),_name(name),_age(age){
}


ISoldier::~ISoldier() {
}

void ISoldier::add(ISoldier* s) {
	
}

void ISoldier::remove(ISoldier* s) {
	
}

void ISoldier::setParent(ISoldier* p) {
	
}

ISoldier* ISoldier::getParent() {
	return nullptr;

}
void ISoldier::getSoldierInfo() {
	printf("职务:%s - 姓名:%s - 年龄:%d\n", _duty.c_str(), _name.c_str(), _age);
}

每个士兵都可以选择它的下级同时也要知道自己的上级是谁。

virtual void add(ISoldier* s);

这个方法就是挑选自己的下级。

virtual void setParent(ISoldier* p);
virtual ISoldier* getParent();

这个方法可以知道自己的上级是谁。

职务士兵：相当于根节点或者树枝节点

//职务士兵
class DutySoldier :public ISoldier {
public:
	DutySoldier(std::string duty, std::string name, int age);

	virtual void add(ISoldier* s)override;
	virtual void remove(ISoldier* s)override;

	virtual void setParent(ISoldier* p)override;
	virtual ISoldier* getParent()override;

	std::vector<ISoldier*> getSubSoldiers()override;
private:
	ISoldier* _parent = nullptr;;
	std::vector<ISoldier*> _soldiers;
};

DutySoldier::DutySoldier(std::string duty, std::string name, int age)
:ISoldier(duty, name, age) {

}

void DutySoldier::add(ISoldier* s) {
	s->setParent(this);
	_soldiers.push_back(s);
}

void DutySoldier::remove(ISoldier* s) {
	int cnt = _soldiers.size();
	for(int i = 0; i < cnt; i++) {
		ISoldier*one = _soldiers.at(i);
		if(one == s) {
			_soldiers.erase(_soldiers.begin() + i);
		}
	}
}

void DutySoldier::setParent(ISoldier* p) {
	_parent = p;
}

ISoldier* DutySoldier::getParent() {
	return _parent;

}

std::vector<ISoldier*> DutySoldier::getSubSoldiers() {
	return _soldiers;
}

战士：相当于叶子节点

//战士
class GunSoldier :public ISoldier {
public:
	GunSoldier(std::string duty, std::string name, int age);
	void setParent(ISoldier* p);
	ISoldier* getParent();
private:
	ISoldier* _parent = nullptr;;
};

GunSoldier::GunSoldier(std::string duty, std::string name, int age) 
:ISoldier(duty, name, age) {
}

void GunSoldier::setParent(ISoldier* p) {
	_parent = p;
}

ISoldier* GunSoldier::getParent() {
	return _parent;
}

作为战士是没有下级是士兵的，多有不需要添加和删除的方法。

客户端调用：

void disPlay(ISoldier* root) {
	if(dynamic_cast<GunSoldier*>(root)) {
		root->getSoldierInfo();
	} else {
		DutySoldier* ss = dynamic_cast<DutySoldier*>(root);
		ss->getSoldierInfo();
		std::vector<ISoldier*> slist = ss->getSubSoldiers();
		int cnt = slist.size();
		for(int i = 0; i < cnt; i++) {
			disPlay(slist.at(i));
		}
	}
}

int main() {

	ISoldier* lianzhang = new DutySoldier("连长", "王连", 36);

	ISoldier* banzhang1 = new DutySoldier("班长", "王班一", 32);
	ISoldier* banzhang2 = new DutySoldier("班长", "王班二", 32);

	ISoldier* soldier1 = new GunSoldier("士兵", "甲", 26);
	ISoldier* soldier2 = new GunSoldier("士兵", "乙", 25);
	ISoldier* soldier3 = new GunSoldier("士兵", "丙", 24);
	ISoldier* soldier4 = new GunSoldier("士兵", "丁", 24);
	ISoldier* soldier5 = new GunSoldier("士兵", "戊", 25);

	lianzhang->add(banzhang1);
	lianzhang->add(banzhang2);

	banzhang1->add(soldier1);
	banzhang1->add(soldier2);
	banzhang1->add(soldier3);

	banzhang2->add(soldier4);
	banzhang2->add(soldier5);


	disPlay(lianzhang);

	return 0;
}

运行结果：

大家看到了，上面就是组合模式的使用，组合模式其实就是同是继承于一个基类并且子类中还包含基类的一种设计模式。如果项目中出现树形的结构，可以考虑使用组合模式，多用于复杂对象的构建使用。

组合模式的优点：
1.节点可以自由的扩展；
2.对高层的调用和对单独节点的调用没有区别。