设计模式中创建型模式 (二）：原型模式

Prototype(原型模式）
简单的讲，就是一种克隆模式，使得一个系统独立于它的产品的创建、构成和表示。
它有和Abstract Factory和Builder一样的效果：它对客户隐藏了具体的产品类。另外，Prototype模式还有另外一些优点：
1、运行时刻增加和删除产品
2、用类动态配置应用。
它的主要缺陷是每一个Prototype的子类都必需实现Clone操作，这可能很困难。例如，当所考虑的类已经存在时就难以新增Clone操作。
当内部包括一些不支持拷贝或有循环引用的对象时，实现克隆可能也会很困难的。
我们将定义MazeFactory的子类MazePrototypeFactory.该子类将使用它要创建的对象的原型来为初始化，这样我们就不需要仅仅为了改变它所
创建的墙壁或房间的类而生子类了。

 

以下为示例代码：（VC6+sp6)下测试通过

 

// MapSite.h
#pragma  warning(disable: 4786)


#include  < vector >
#include  < map >
#include  < iostream >
using   namespace  std;


// ##ModelId=48059C280115
enum  Direction
... {
    North, South, East, West
} ;

/**/ //
// 申明所有类
class  Door;
class  MapSite;
class  Maze;
class  MazeBuilder;
class  MazeFactory;
class  MazeGame;
class  Room;
class  StandardMazeBuilder;
class  Wall;
class  MazePrototypeFactory;
/**/ //

// ##ModelId=48059C2800E6
class  MapSite
... {
public:
    //##ModelId=48059C280105
    virtual void Enter() = 0;
} ;

// ##ModelId=48059C280172
class  Wall:  public  MapSite
... {
public:
    //##ModelId=48059C280183
    Wall()...{}

    virtual Wall* Clone() const;

    //##ModelId=48059C280184
    virtual void Enter()...{printf("Wall::Enter() "); }
} ;


// ##ModelId=48059C280134
class  Room:  public  MapSite
... {
public:
    //##ModelId=48059C280144
    Room (int roomNo = 0)...{ _roomNumber = roomNo; }
    //##ModelId=48059C280146
    MapSite* GetSide(Direction d)const...{ return _sides[d]; }
    //##ModelId=48059C280154
    void SetSide (Direction d, MapSite* s)...{ _sides[d] = s; }
    
    Room(const Room& other);
    virtual Room* Clone();
    virtual void Initialize(int n);
    //##ModelId=48059C280157
    virtual void Enter()...{ printf("Room::Enter() "); }
    
    //##ModelId=48059C280159
    int GetRoomNo()const...{ return _roomNumber; }
private:
    //##ModelId=48059C280164
    MapSite* _sides[4];
    //##ModelId=48059C280168
    int _roomNumber;
} ;

// ##ModelId=48059C280191
class  Door:  public  MapSite
... {
public:
    //##ModelId=48059C2801A1
    Door(Room* r1= 0, Room* r2= 0)...{ _room1 = r1;_room2 = r2; }

    Door(const Door& other);
    
    virtual void Initialize(Room *r1, Room* r2);
    virtual Door* Clone() const;
    //##ModelId=48059C2801A4
    virtual void Enter()...{ printf("Door::Enter() "); };
    //##ModelId=48059C2801A6
    Room* OtherSideFrom(Room*);
private:
    //##ModelId=48059C2801A9
    Room * _room1;
    //##ModelId=48059C2801B2
    Room * _room2;
    //##ModelId=48059C2801B6
    bool _isOpen;
} ;

// ##ModelId=48059C2801C0
class  Maze
... {
public:
    //##ModelId=48059C2801D0
    Maze()...{ }
    
    Maze(const Maze& other);
    virtual Maze* Clone();

    //##ModelId=48059C2801D1
    void AddRoom(Room* r)
    ...{
        maproom[r->GetRoomNo()] = r;
    }
    //##ModelId=48059C2801D3
    Room* RoomNo(int no)...{ return maproom[no]; }
    
private:
    //##ModelId=48059C2801EF
    map<int, Room*> maproom;
    //
} ;


// 建造迷宫的程序将MazeFactory作为一个参数，这样程序员就能指定要创建的房间，
// 墙壁和门等类
// ##ModelId=48059C2801FF
class  MazeFactory
... {
public:
    //##ModelId=48059C280200
    MazeFactory()...{}
    
    //##ModelId=48059C280201
    virtual Maze* MakeMaze()const
    ...{
        return new Maze;
    }
    //##ModelId=48059C280203
    virtual Wall* MakeWall()const
    ...{
        return new Wall;
    }
    //##ModelId=48059C28020F
    virtual Room* MakeRoom(int n)const
    ...{
        return new Room(n);
    }
    //##ModelId=48059C280212
    virtual Door* MakeDoor(Room* r1, Room* r2)const
    ...{
        return new Door(r1, r2);
    }
} ;


// 创建各个部件，作用类似于MazeGame::CreateMaze();
// ##ModelId=48059C28021E
class  MazeBuilder
... {
public:
    //##ModelId=48059C28021F
    virtual void BuildMaze()...{}
    //##ModelId=48059C280221
    virtual void BuildRoom(int room)...{}
    //##ModelId=48059C28022F
    virtual void BuildDoor(int roomFrom,int roomTo)...{}

    //##ModelId=48059C280233
    virtual Maze* GetMaze()...{ return 0; }
protected:
    //##ModelId=48059C280235
    MazeBuilder()...{}

} ;

class  StandardMazeBuilder:  public  MazeBuilder
... {
public:
    StandardMazeBuilder()...{ _currentMaze = 0; }

    virtual void BuildMaze()...{ _currentMaze = (Maze*) new StandardMazeBuilder; }
    virtual void BuildRoom(int);
    virtual void BuildDoor(int,int);

    virtual Maze* GetMaze()...{ return _currentMaze; }
private:
    Direction CommonWall(Room*, Room*);//决定哪两个相邻的墙可以有门。
    Maze* _currentMaze;
} ;


// 创建迷宫的类
// ##ModelId=48059C28023D
class  MazeGame:  public  Maze
... {
public:
    //##ModelId=48059C28023F
    Maze* CreateMaze();//普通方法创建迷宫，硬编码方式
    
    //##ModelId=48059C28024D
    Maze* CreateMaze2(MazeFactory& factory);//工厂类方式建造

    Maze* CreateMaze3(StandardMazeBuilder& builder);//builder模式，建分部
    

    Maze* CreateMaze4(MazePrototypeFactory& prototype);//原型模式
    //##ModelId=48059C28024F
    void printMaze()
    ...{
        //好像比较麻烦
    }
} ;


class  MazePrototypeFactory:  public  MazeFactory
... {
public:
    MazePrototypeFactory(Maze* m,Wall* w, Room* r, Door* d)
    ...{
        _prototypeMaze = m;
        _prototypeRoom = r;
        _prototypeWall = w;
        _prototypeDoor = d;
    }

    virtual Maze* MakeMaze() const;
    virtual Room* MakeRoom(int n) const;
    virtual Wall* MakeWall() const;
    virtual Door* MakeDoor(Room* r1, Room* r2) const;

private:
    Maze* _prototypeMaze;
    Room* _prototypeRoom;
    Wall* _prototypeWall;
    Door* _prototypeDoor;
} ;

//  MapSite.cpp : Defines the entry point for the console application.
//

#include  " stdafx.h "

#include  " MapSite.h "
Wall *  Wall::Clone()  const
... {
    return new Wall(*this);
}


Room::Room( const  Room &  other)
... {
    this->_roomNumber = other._roomNumber;
    memcpy(this->_sides,other._sides,sizeof(_sides));
}
Room *  Room::Clone()
... {
    return new Room(*this);
}
void  Room::Initialize( int  n)
... {
    this->_roomNumber = n;
}


Door::Door( const  Door &  other)
... {
    _room1 = other._room1;
    _room2 = other._room2;
}

void  Door::Initialize(Room  * r1, Room *  r2)
... {
    _room1 = r1;
    _room2 = r2;
}

Door *  Door::Clone()  const
... {
    return new Door(*this);
}

Maze::Maze( const  Maze &  other)
... {
    maproom.clear();
    //maproom.insert(other.maproom.begin(),other.maproom.end());
    map<int, Room*>::const_iterator it;
    it = other.maproom.begin();
    for ( ;it != other.maproom.end(); it++)
    ...{
        maproom.insert(*it);
    }
}

Maze *  Maze::Clone()
... {
    return new Maze(*this);
}

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);
}

Direction StandardMazeBuilder::CommonWall(Room *  r1, Room *  r2)
... {
    if(r1 == NULL || r2 == NULL )
        return North;
    if(r1->GetSide(North) == r2->GetSide(South))
        return North;
    if(r1->GetSide(South) == r2->GetSide(North))
        return South;
    if(r1->GetSide(West) == r2->GetSide(East))
        return West;
    if(r1->GetSide(East) == r2->GetSide(West))
        return East;
    return North;
}



// ##ModelId=48059C28023F
Maze *  MazeGame::CreateMaze()
... {
    Maze* aMaze = new Maze;
    Room* r1 = new Room(1);
    Room* r2 = new Room(2);
    Door* theDoor = new Door(r1,r2);
    
    aMaze->AddRoom(r1);
    aMaze->AddRoom(r2);
    
    r1->SetSide(North, new Wall);
    r1->SetSide(East, theDoor);
    r1->SetSide(South, new Wall);
    r1->SetSide(West, new Wall);
    
    
    r2->SetSide(North, new Wall);
    r2->SetSide(East, new Wall);
    r2->SetSide(South, new Wall);
    r2->SetSide(West, theDoor);
    
    return aMaze;
}  


// ##ModelId=48059C28024D
Maze *  MazeGame::CreateMaze2(MazeFactory &  factory)
... {
    Maze* aMaze = factory.MakeMaze();
    Room* r1 = factory.MakeRoom(1);
    Room* r2 = factory.MakeRoom(2);
    Door* aDoor = factory.MakeDoor(r1, r2);
    
    aMaze->AddRoom(r1);
    aMaze->AddRoom(r2);
    
    r1->SetSide(North, factory.MakeWall());
    r1->SetSide(East, aDoor);
    r1->SetSide(South, factory.MakeWall());
    r1->SetSide(West, factory.MakeWall());
    
    r2->SetSide(North, factory.MakeWall());
    r2->SetSide(East, factory.MakeWall());
    r2->SetSide(South, factory.MakeWall());
    r2->SetSide(West, aDoor);
    return aMaze;
}

Maze *  MazeGame::CreateMaze3(StandardMazeBuilder &  builder)
... {
    builder.BuildMaze();

    builder.BuildRoom(1);
    builder.BuildRoom(2);
    builder.BuildDoor(1, 2);

    return builder.GetMaze();
}

Maze *  MazeGame::CreateMaze4(MazePrototypeFactory &  prototype)
... {
    Maze* aMaze = prototype.MakeMaze();
    Room* r1 = prototype.MakeRoom(1);
    Room* r2 = prototype.MakeRoom(2);
    Door* aDoor = prototype.MakeDoor(r1, r2);
    
    aMaze->AddRoom(r1);
    aMaze->AddRoom(r2);
    
    r1->SetSide(North, prototype.MakeWall());
    r1->SetSide(East, aDoor);
    r1->SetSide(South, prototype.MakeWall());
    r1->SetSide(West, prototype.MakeWall());
    
    r2->SetSide(North, prototype.MakeWall());
    r2->SetSide(East, prototype.MakeWall());
    r2->SetSide(South, prototype.MakeWall());
    r2->SetSide(West, aDoor);

    return aMaze;
}

Maze *  MazePrototypeFactory::MakeMaze()  const
... {
    return _prototypeMaze->Clone();
}

Wall *  MazePrototypeFactory::MakeWall()  const
... {
    return _prototypeWall->Clone();
}

Room *  MazePrototypeFactory::MakeRoom( int  n)  const
... {
    Room* room = _prototypeRoom->Clone();
    room->Initialize(n);
    return room;
}

Door *  MazePrototypeFactory::MakeDoor (Room *  r1, Room *  r2)  const  
... {
    Door* door = _prototypeDoor->Clone();
    door->Initialize(r1, r2);
    return door;
}

//  testMapSite.cpp : Defines the entry point for the console application.
//

#include  " stdafx.h "
#include  " MapSite.h "
int  main( int  argc,  char *  argv[])
... {
    printf("Hello World! ");

    MazeGame game;
    MazePrototypeFactory simpleMazeFactory(new Maze, new Wall, new Room, new Door);
    Maze* maze = game.CreateMaze4(simpleMazeFactory);
    return 0;
}