Sample Code
//创建者基类 这个类提供创建复杂对象的接口 接口的实现在子类中实现
   class MazeBuilder {
   public:
//三个创建接口
       virtual void BuildMaze() { }
       virtual void BuildRoom(int room) { }
       virtual void BuildDoor(int roomFrom, int roomTo) { }
//取得创建结果的接口    
       virtual Maze* GetMaze() { return 0; }
   protected:
       MazeBuilder();
   };

//客户，MazeGame是使用这个对象的客户
   Maze* MazeGame::CreateMaze (MazeBuilder& builder) {
       builder.BuildMaze();
   
       builder.BuildRoom(1);
       builder.BuildRoom(2);
       builder.BuildDoor(1, 2);
   
       return builder.GetMaze();
   }

The builder hides the internal representation of the Maze and how these parts are assembled to complete the final maze. (No walls?)
//创建者子类 对基类中方法进行实现 以便控制创建结果
   class StandardMazeBuilder : public MazeBuilder {
   public:
       StandardMazeBuilder();
   
       virtual void BuildMaze();
       virtual void BuildRoom(int);
       virtual void BuildDoor(int, int);
   
       virtual Maze* GetMaze();
   private:
       Direction CommonWall(Room*, Room*);
       Maze* _currentMaze;
   };

   StandardMazeBuilder::StandardMazeBuilder () {
       _currentMaze = 0;}

   void StandardMazeBuilder::BuildMaze () {
       _currentMaze = new Maze;
   }
   
   Maze* StandardMazeBuilder::GetMaze () {
       return _currentMaze;
   }

   void StandardMazeBuilder::BuildRoom (int n) {
       if (!_currentMaze->RoomNo(n)) {
           Room* room = new Room(n);
           _currentMaze->AddRoom(room);
   
           room->SetSide(North, new Wall);
           room->SetSide(South, new Wall);
           room->SetSide(East, new Wall);
           room->SetSide(West, new Wall);
       }
   }

   void StandardMazeBuilder::BuildDoor (int n1, int n2) {
       Room* r1 = _currentMaze->RoomNo(n1);
       Room* r2 = _currentMaze->RoomNo(n2);
       Door* d = new Door(r1, r2);
   
       r1->SetSide(CommonWall(r1,r2), d);
       r2->SetSide(CommonWall(r2,r1), d);
   }


//例子
Maze* maze;
   MazeGame game;
   StandardMazeBuilder builder;
   //在这里进行创建 产生一个maze
   game.CreateMaze(builder);
   maze = builder.GetMaze();



//第二个子类 提供第二种创建方法
   class CountingMazeBuilder : public MazeBuilder {
   public:
       CountingMazeBuilder();
   
       virtual void BuildMaze();
       virtual void BuildRoom(int);
       virtual void BuildDoor(int, int);
       virtual void AddWall(int, Direction);
   
       void GetCounts(int&, int&) const;
   private:
       int _doors;
       int _rooms;
   };

CountingMazeBuilder::CountingMazeBuilder () {
       _rooms = _doors = 0;
   }
   
   void CountingMazeBuilder::BuildRoom (int) {
       _rooms++;
   }
   
   void CountingMazeBuilder::BuildDoor (int, int) {
       _doors++;
   }
   
   void CountingMazeBuilder::GetCounts (
       int& rooms, int& doors
   ) const {
       rooms = _rooms;
       doors = _doors;
   }
//使用例子
int rooms, doors;
   MazeGame game;
   CountingMazeBuilder builder;
   //创建并返回对象 和上面相比 不同点在于传进去的子类不同了 这里是传CountingMazeBuilder 类的对象 所以产生结果也不一样
   game.CreateMaze(builder);
   builder.GetCounts(rooms, doors);
   
   cout << "The maze has "
        << rooms << " rooms and "
        << doors << " doors" << endl;