// Purpose.  Builder                    class Builder { public:
 //                                         virtual void addFront( char ) = 0;
 // The monolithic design supports a        virtual void addBack( char ) = 0;
 // single representation.  The Builder     virtual Array& getResult()  = 0;
 // design allows a different rep per    };
 // Builder derived class, and the com-
 // mon input and parsing have been de-  class BuilderOne : public Builder {
 // fined in the Director class.  The D  public:
 // constructs, the B returns result.       void addFront( char ch ) {
                                               one.lst.push_back( ch ); }
 class Array {                              void addBack( char ch ) {
 public:                                       one.lst.push_back( ch ); }
    void addFront( char ch ) {              Array& getResult() {
       lst.push_front( ch ); }                 return one; }
    void addBack( char ch ) {            private:
       lst.push_back( ch ); }               OneEnded one;
    void traverse() {                    };
       for (i=0; i < lst.size(); i++)
          cout << lst[i] << ' ';         class BuilderTwo : public Builder {
       cout << endl; }                   public:
 private:                                   void addFront( char ch ) {
    deque<char> lst;   int i;                  two.lst.push_front( ch ); }
 };                                         void addBack( char ch ) {
                                               two.lst.push_back( ch ); }
 string in[] = { "fa", "bb", "fc",          Array& getResult() {
    "bd", "fe", "bf", "fg", "bh" };            return two; }
                                         private:
 void main( void ) {                        TwoEnded two;
    Array  list;                         };
    for (int i=0; i < 8; i++)
       if (in[i][0] == 'f')              string in[] = { "fa", "bb", "fc",
          list.addFront( in[i][1] );        "bd", "fe", "bf", "fg", "bh" };
       else if (in[i][0] == 'b')
          list.addBack( in[i][1] );      class Director {
    list.traverse(); }                   public:
                                            Director( Builder* b ) {
 // g e c a b d f h                            setBuilder( b ); }
                                            void setBuilder( Builder* b ) {
 ///////////////////\\\\\\\\\\\\\\\\\\\        bldr = b; }
                                            void construct() {
 class Array { public:                         for (int i=0; i < 8; i++)
    virtual void traverse() = 0;                  if (in[i][0] == 'f')
 };                                                  bldr->addFront(in[i][1]);
                                                  else if (in[i][0] == 'b')
 class OneEnded : public Array {                     bldr->addBack(in[i][1]);
 public:                                    }
    friend class BuilderOne;             private:
    void traverse() {                       Builder* bldr;
       for (i=0; i < lst.size(); i++)    };
          cout << lst[i] << ' ';
       cout << endl; }                   void main( void ) {
 private:                                   BuilderOne one;
    vector<char> lst;   int i;              BuilderTwo two;
 };                                         Director dir( &one );

 class TwoEnded : public Array {            dir.construct();
 public:                                    one.getResult().traverse();
    friend class BuilderTwo;                dir.setBuilder( &two );
    void traverse() {                       dir.construct();
       for (i=0; i < lst.size(); i++)       two.getResult().traverse();
          cout << lst[i] << ' ';         }
       cout << endl; }
 private:                                // a b c d e f g h
    deque<char> lst;   int i;            // g e c a b d f h
 };