Headfirst设计模式的C++实现——组合模式(Composite)

menu_component.h

 #ifndef _MENU_COMPONENT_H_
 #define _MENU_COMPONENT_H_

 #include <string>

 class MenuComponent {
 public:
     class Iterator {
     public:
         virtual bool has_next() = ;

         virtual MenuComponent *next() = ;
     };

     MenuComponent( const std::string &_name, const std::string &_description ) :
         name(_name), description(_description) {}

     const std::string& get_name() { return name; }

     const std::string& get_description() { return description; }

     virtual void print() = ;

     virtual Iterator *get_iterator() = ;
 private:
     std::string name;
     std::string description;
 };
 #endif

menu_item.h

 #ifndef _MENU_ITEM_H_
 #define _MENU_ITEM_H_

 #include "menu_component.h"
 #include <iostream>

 class MenuItem : public MenuComponent {
 public:
     MenuItem( const std::string &_name, const std::string &_description, double _price, bool _vegetarian ) :
         MenuComponent( _name, _description ), price(_price), vegetarian(_vegetarian) {} 

     void print() {
         std::cout << get_name() << " "
                   << get_description() << " "
                   << get_price() << " "
                   << is_vegetarian() << std::endl;
     }

     double get_price() { return price; }

     bool is_vegetarian() { return vegetarian; }

     Iterator *get_iterator() { return NULL; }
 private:
     double price;
     bool vegetarian;
 };
 #endif

menu.h

 #ifndef _MENU_H_
 #define _MENU_H_

 #include "ivector.h"
 #include <stack>

 class Menu : public MenuComponent{
 public:
     Menu( const std::string &_name, const std::string &_description ) :
         MenuComponent( _name, _description ),
         _iterator( menu_components.get_iterator() ) {}

     void add( MenuComponent* component ) { menu_components.add( component ); }

     void print() { std::cout << get_name() << " " << get_description() << std::endl; }

     Iterator *get_iterator() { return &_iterator; }

 private:
     IVector menu_components;

     class _Iterator : public Iterator {
     public:
         _Iterator( Iterator *it) { s.push(it); }

         bool has_next() {
             if ( s.empty() ) { return false; }
             if ( s.top()->has_next() ) { return true; }
             s.pop();
             return has_next();
         }

         MenuComponent *next() {
             if ( has_next() ) {
                 MenuComponent *next = s.top()->next();
                 if ( NULL != next->get_iterator() ) { s.push( next->get_iterator() );}
                 return next;
             }
         }
     private:
         std::stack<Iterator *> s;
     } _iterator;
 };
 #endif

ivector.h

 #ifndef _IVECTOR_H_
 #define _IVECTOR_H_

 #include "menu_component.h"
 #include <vector>

 class IVector{
 public:
     IVector() : data_iterator( *this ) {}

     void add( MenuComponent *component ) { data_v.push_back( component ); }

     MenuComponent::Iterator *get_iterator() { return &data_iterator; }
 private:
     std::vector<MenuComponent *> data_v;

     class _Iterator : public MenuComponent::Iterator {
     public:
         _Iterator (IVector &_ivector) : ivector(_ivector), pos() {}

         bool has_next() { return pos < ivector.data_v.size(); }

         MenuComponent *next() { return ivector.data_v[pos++]; }
     private:
         int pos;

         IVector &ivector;
     } data_iterator;
 };
 #endif

main.cpp

 #include "menu_item.h"
 #include "menu.h"

 int main() {

     Menu *p = new Menu("total", "total");
     p->add(new MenuItem("MenuItem 1", "test description", 9.4, true));
     p->add(new MenuItem("MenuItem 2", "test description", 9.4, true));

     Menu *p1 = new Menu("sub menu", "test description");
     p1->add(new MenuItem("MenuItem 3", "test description", 9.4, true));
     p1->add(new MenuItem("MenuItem 4", "test description", 9.4, true));
     p->add(p1);

     MenuComponent::Iterator *it = p->get_iterator();
     while ( it->has_next() ) {
         MenuItem *menu_item = (MenuItem *)it->next();
         menu_item->print();
     }

     return ;
 }