组合模式
组合模式在参考链接中已经讲得很好了，这里只简单讲讲就好。
组合模式的意图是表达部分-整体层次结构。
当你需要管理一个组合对象，又要管理这个组合对象的单个对象。这个时候就可以让这个组合对象和单个对象继承同一个基类，以便用基类指针做统一管理。
当基类指针去调用operation方法时，如果这个这个指针指向的是Composite对象，则调用的是Composite对象的operation方法，这个方法中的for循环会挨个遍历各个vector中的指针，如果遍历的指针指向的还是Composite对象，则继续调用Composite对象的operation方法。如果指针指向的单元是Leaf对象，则会调用Leaf对象中的operation方法。
如果不是写成组合模式，一般常用的递归函数会怎么写？首先也是遍历父节点，如果父节点有子节点就去遍历子节点，直到遍历完叶子节点。组合模式比较巧妙的是，在编译的时候，虚函数operation已经根据指针是指向基类还是子类分好了，所以递归函数中省去了判断是否是叶子节点的过程，而是让指针自行去判断。（设计模式经常干的一件事就是：把需用判断的地方巧妙的用继承虚函数来实现）
组合模式+迭代器模式
怎么用迭代器的方式去迭代Composite对象呢？
可以相应写一个CompositeIterator对象。迭代器其实有点像一个托管，对象将自己的链接地址给到迭代器，由迭代器的hasNext判断后面还有没数据，由next返回下一个容器对象。
关键代码
next(): 返回下一个对象，同时把composite对象创建的迭代器加入到iterators容器中。
hasNext(): 判断是否可迭代，如果不可迭代则继续删除此迭代器，继续寻找到下一个可迭代的迭代器。找到则返回true。
template<class T>
class CompositeIterator : public Iterator<T>{
public:
CompositeIterator(Iterator<T>* iterator){ iterators.push_back(iterator); }
T next(){
Iterator<T>* iterator = iterators[0];
T item = iterator->next();
iterator = item->createIterator();
if(iterator->hasNext()){ // 这里leaf的迭代器hasNext返回的是false，故而不会添加进去
iterators.push_back(iterator);
}
return item;
}
bool hasNext(){
if(iterators.size()==0) return false;
Iterator<T>* iterator = iterators[0];
if(!iterator->hasNext()){
iterators.erase(iterators.begin()); // 已经没法迭代了，继续下一个迭代对象
return hasNext();
} else {
return true;
}
}
private:
vector<Iterator<T>*> iterators;
};统一vsctor接口代码
这里为了让vector的迭代器也有hasNext()和next()接口，重写了一个newVector对象，其行为类似vector。文章来源：https://www.toymoban.com/news/detail-817478.html
template<class T>
class Iterator{
public:
virtual bool hasNext(){}
virtual T next(){}
virtual bool isComposite(){}
};
template<class T>
class newVectorIterator : public Iterator<T>{
public:
newVectorIterator(vector<T> *p):p(p){}
T next(){
T t = p->at(position);
position++;
return t;
}
bool hasNext(){
if(position >= p->size())
return false;
else
return true;
}
vector<T> *p;
int position = 0;
};
template<class T>
class newVector{
public:
void push_back(T item){
mVector.push_back(item);
}
T operator[](int index){
return mVector[index];
}
int size(){
return mVector.size();
}
Iterator<T>* createIterator(){
return new newVectorIterator<T>(&mVector);
}
vector<T> mVector;
};全部代码
#include<iostream>
#include<string>
#include<vector>
using namespace std;
template<class T>
class Iterator{
public:
virtual bool hasNext(){}
virtual T next(){}
virtual bool isComposite(){}
};
template<class T>
class newVectorIterator : public Iterator<T>{
public:
newVectorIterator(vector<T> *p):p(p){}
T next(){
T t = p->at(position);
position++;
return t;
}
bool hasNext(){
if(position >= p->size())
return false;
else
return true;
}
vector<T> *p;
int position = 0;
};
template<class T>
class newVector{
public:
void push_back(T item){
mVector.push_back(item);
}
T operator[](int index){
return mVector[index];
}
int size(){
return mVector.size();
}
Iterator<T>* createIterator(){
return new newVectorIterator<T>(&mVector);
}
vector<T> mVector;
};
template<class T>
class NullIterator : public Iterator<T>{
public:
T next(){ return nullptr; }
bool hasNext(){ return false; }
};
template<class T>
class CompositeIterator : public Iterator<T>{
public:
CompositeIterator(Iterator<T>* iterator){ iterators.push_back(iterator); }
T next(){
Iterator<T>* iterator = iterators[0];
T item = iterator->next();
iterator = item->createIterator();
if(iterator->hasNext()){
iterators.push_back(iterator);
}
return item;
}
bool hasNext(){
if(iterators.size()==0) return false;
Iterator<T>* iterator = iterators[0];
if(!iterator->hasNext()){
iterators.erase(iterators.begin());
return hasNext();
} else {
return true;
}
}
private:
vector<Iterator<T>*> iterators;
};
class Compoment{
public:
virtual ~Compoment(){ std::cout << "~Compoment()" << endl; }
virtual void operation() = 0;
virtual void operation1() = 0;
virtual void add(Compoment *com){}
virtual void remove(Compoment *com){}
virtual Compoment* findChild(int index){ return nullptr; }
virtual Iterator<Compoment*>* createIterator(){}
};
class Leaf : public Compoment{
public:
Leaf(int num) : num(num) {}
~Leaf(){ std::cout << "~Leaf()" << num << endl;}
virtual void operation() { cout << "Leaf::operation()" << num << endl; }
void operation1(){ std::cout << "Leaf::operation1()" << num << std::endl; }
Iterator<Compoment*>* createIterator(){
return new NullIterator<Compoment*>();
}
private:
int num;
};
class Composite : public Compoment{
public:
Composite(){}
~Composite(){
std::cout << "~Composite()" << std::endl;
}
void operation(){
std::cout << "Composite::operation()" << std::endl;
for(int i = 0; i < coms.size(); i ++ ){
coms[i]->operation();
}
}
void operation1(){
std::cout << "Composite::operation1()" << std::endl;
}
bool isComposite(){ return true; }
void add(Compoment *com){ coms.push_back(com); }
Compoment* findChild(int index){
if(index < 0 || index >= coms.size()){
return nullptr;
}
return coms[index];
}
Iterator<Compoment*>* createIterator(){
return new CompositeIterator<Compoment*>(coms.createIterator());
}
private:
newVector<Compoment*> coms;
};
void doCompositePattern(){
std::cout << "-----------com1->operation()-----------" << std::endl;
Compoment *com1 = new Composite();
com1->add(new Leaf(1));
com1->add(new Leaf(2));
com1->add(new Leaf(3));
com1->operation();
std::cout << "-----------com2->operation()-----------" << std::endl;
Compoment *com2 = new Composite();
com2->add(new Leaf(4));
com2->add(com1);
com2->add(com1);
com1->add(new Leaf(11));
com2->operation();
std::cout << "\n-----------iterator-----------" << std::endl;
Iterator<Compoment*>* iterator = com2->createIterator();
while(iterator->hasNext()){
iterator->next()->operation1();
}
}
int main(){
doCompositePattern();
return 0;
}参考
C++设计模式——组合模式（composite pattern）_c++ 设计模式组合-CSDN博客文章来源地址https://www.toymoban.com/news/detail-817478.html
到了这里，关于（十）Head first design patterns组合模式（c++）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
