Headfirst设计模式的C++实现——复合模式

observer.h

 #ifndef _OBSERVER_H_
 #define _OBSERVER_H_

 #include <string>
 class Observer {
 public:
     virtual void update(const std::string &type) = ;
 };
 #endif

quack_observable.h

 #ifndef _QUACK_OBSERVABLE_H_
 #define _QUACK_OBSERVABLE_H_

 #include "observer.h"

 class QuackObservable {
 public:
     virtual void register_observer(Observer *observer) = ;
     virtual void notify_observers() = ;
 };
 #endif

duck.h

 #ifndef _DUCK_H_
 #define _DUCK_H_

 #include "quack_observable.h"
 class Duck : public QuackObservable{
 public:
     virtual void quack() = ;
 };
 #endif

observable.h

 #ifndef _OBSERVABLE_H_
 #define _OBSERVABLE_H_

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

 class Observable : public QuackObservable {
 private:
     std::vector<Observer *> observers;
     const std::string type;
 public:
     Observable( const std::string &_type ) : type(_type) {}
     void register_observer(Observer *observer) { observers.push_back( observer ); }
     void notify_observers() {
         for ( std::vector<Observer *>::iterator it = observers.begin();
               it < observers.end();
               it ++ ) {
             (*it)->update( type );
         }
     }
 };
 #endif

mallard_duck.h

 #ifndef _MALLARD_DUCK_H_
 #define _MALLARD_DUCK_H_

 #include <iostream>
 #include "duck.h"
 #include "observable.h"

 class MallardDuck : public Duck{
 private:
     Observable observable;
 public:
     MallardDuck() :observable("Mallard duck") {}
     void quack() { std::cout << "Quack" << std::endl; notify_observers(); }
     void register_observer(Observer *observer) { observable.register_observer(observer); }
     void notify_observers() { observable.notify_observers(); }
 };

 #endif

redhead_duck.h

 #ifndef _REDHEAD_DUCK_H_
 #define _REDHEAD_DUCK_H_

 #include <iostream>
 #include "duck.h"
 #include "observable.h"
 class RedheadDuck : public Duck{
 private:
     Observable observable;
 public:
     RedheadDuck() :observable("Redhead Duck") {}
     void quack() { std::cout << "Quack" << std::endl; notify_observers();}
     void register_observer(Observer *observer) { observable.register_observer(observer); }
     void notify_observers() { observable.notify_observers(); }
 };

 #endif

duck_call.h

 #ifndef _DUCK_CALL_H_
 #define _DUCK_CALL_H_

 #include <iostream>
 #include "duck.h"
 #include "observable.h"

 class DuckCall : public Duck{
 private:
     Observable observable;
 public:
     DuckCall() :observable("Duck call") {}
     void quack() { std::cout << "Kwak" << std::endl; notify_observers(); }
     void register_observer(Observer *observer) { observable.register_observer(observer); }
     void notify_observers() { observable.notify_observers(); }
 };

 #endif

rubber_duck.h

 #ifndef _RUBBER_DUCK_H_
 #define _RUBBER_DUCK_H_

 #include <iostream>
 #include "duck.h"
 #include "observable.h"
 class RubberDuck : public Duck{
 private:
     Observable observable;
 public:
     RubberDuck() :observable("Rubber Duck") {}
     void quack() { std::cout << "Squeak" << std::endl; notify_observers();}
     void register_observer(Observer *observer) { observable.register_observer(observer); }
     void notify_observers() { observable.notify_observers(); }
 };

 #endif

countable_duck.h

 #ifndef _COUNTEABLE_DUCK_H_
 #define _COUNTEABLE_DUCK_H_

 #include "duck.h"
 class CountableDuck : public Duck{
 public:
     CountableDuck( Duck *_duck ) : duck(_duck) {}
     void quack() { duck->quack();  quack_count ++; }
     void register_observer(Observer *observer) { duck->register_observer(observer); }
     void notify_observers() { duck->notify_observers(); }
     static int get_quack_count() { return quack_count; }
 private:
     Duck *duck;
     static int quack_count;
 };
 #endif

countable_duck.cpp

 #include "countable_duck.h"

 int CountableDuck::quack_count = ;

ivector.h

 #ifndef _IVECTOR_H_
 #define _IVECTOR_H_

 #include <vector>
 #include <stdlib.h>

 template<class T> class IVector {
 public:
     IVector() : pos() {}
     void add( const T& t ) { t_v.push_back(t); }
     bool has_next() { return pos < t_v.size(); }
     T* next() {
         if ( has_next() ) {
             return &(t_v[pos++]);
         }
         return NULL;
     }
     void back_to_begin() { pos = ; }
 private:
     int pos;
     std::vector<T> t_v;
 };
 #endif

duck_factory.h

 #ifndef _DUCK_FACTORY_H_
 #define _DUCK_FACTORY_H_

 #include "mallard_duck.h"
 #include "redhead_duck.h"
 #include "duck_call.h"
 #include "rubber_duck.h"
 #include "countable_duck.h"
 #include <string>

 class SimpleDuckFactory {
 public:
     static Duck* create_duck( std::string type ) {
         if ( type == "mallard" ) { return new CountableDuck( new MallardDuck ); }
         if ( type == "redhead" ) { return new CountableDuck( new RedheadDuck ); }
         if ( type == "call" )    { return new CountableDuck( new DuckCall ); }
         if ( type == "rubber" )  { return new CountableDuck( new RubberDuck ); }
         return NULL;
     }
 };

 class AbstractDuckFactory {
 public:
     static Duck *create_mallard_duck() { return new CountableDuck( new MallardDuck ); }
     static Duck *create_redhead_duck() { return new CountableDuck( new RedheadDuck ); }
     static Duck *create_duck_call() { return new CountableDuck( new DuckCall ); }
     static Duck *create_rubber_duck() { return new CountableDuck( new RubberDuck ); }
 };
 #endif

flock.h

 #ifndef _FLOCK_H_
 #define _FLOCK_H_

 #include "duck.h"
 #include "ivector.h"

 class Flock : public Duck{
 public:
     void quack() {
         ducks.back_to_begin();
         while( ducks.has_next() ) {
             (*(ducks.next()))->quack();
         }
     }
     void add( Duck *duck ) { ducks.add(duck); }
     void register_observer(Observer *observer) {
         ducks.back_to_begin();
         while( ducks.has_next() ) {
             (*(ducks.next()))->register_observer(observer);
         }
     }
     void notify_observers() {
         ducks.back_to_begin();
         while( ducks.has_next() ) {
             (*(ducks.next()))->notify_observers();
         }
     }
 private:
     IVector<Duck *> ducks;
 };
 #endif

goose.h

 #ifndef _GOOSE_H_
 #define _GOOSE_H_

 #include <iostream>
 class Goose {
 public:
     void honk() { std::cout << "Honk" << std::endl; }
 };
 #endif

goose_adapter.h

 #ifndef _GOOSE_ADAPTER_H_
 #define _GOOSE_ADAPTER_H_

 #include "goose.h"
 #include "duck.h"
 #include "observable.h"

 class GooseAdapter : public Duck{
 public:
     GooseAdapter( Goose *_goose ) : goose(_goose), observable("Goose pretending to be a duck") {}
     void quack() { goose->honk(); notify_observers();}
     void register_observer(Observer *observer) { observable.register_observer(observer); }
     void notify_observers() { observable.notify_observers(); }
 private:
     Goose *goose;
     Observable observable;
 };
 #endif

quackologist.h

 #ifndef _QUACK_OLOGIST_H_
 #define _QUACK_OLOGIST_H_

 #include "observer.h"
 #include <iostream>
 #include <string>

 class QuackOlogist : public Observer {
 public:
     void update(const std::string &type ) { std::cout << "Quackologist: " << type << " just quacked." << std::endl; }
 };
 #endif

main.cpp

 #include "goose_adapter.h"
 #include "duck_factory.h"
 #include "countable_duck.h"
 #include <iostream>
 #include "flock.h"
 #include "quackologist.h"

 void simulate(Duck *duck) {
     if ( NULL != duck ) { duck->quack(); }
 }

 int main() {
     Flock *flock_of_mallard = new Flock;
     flock_of_mallard->add( AbstractDuckFactory::create_mallard_duck() );
     flock_of_mallard->add( AbstractDuckFactory::create_mallard_duck() );

     Flock *flock_of_ducks = new Flock;

     flock_of_ducks->add( new CountableDuck(new GooseAdapter( new Goose )));

     flock_of_ducks->add( AbstractDuckFactory::create_redhead_duck() );
     flock_of_ducks->add( AbstractDuckFactory::create_duck_call() );
     flock_of_ducks->add( AbstractDuckFactory::create_rubber_duck() );

     flock_of_ducks->add( flock_of_mallard );

     QuackOlogist quackologist;
     flock_of_ducks->register_observer(&quackologist);

     simulate( flock_of_ducks );

     std::cout << "quack count: " << CountableDuck::get_quack_count() << std::endl;
 };