设计模式学习笔记（工厂模式）

一、定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式使一个类的实例化延迟到其子类。

C++中的工厂方法（工厂基类中所定义的创建产品的函数）都是虚函数并且常常是纯虚函数。

二、参与者

Product：（工厂基类）定义工厂方法所创建的接口；

ConcreteProduct：（工厂具体类）实现Product接口；

Creator：声明工厂方法，返回一个Product对象；

ConcreteCreator：重新定义工厂方法返回一个ConcreteProduct实例。

三、问题：

Creator声明工厂方法Create，返回一个Product对象

class Creator{
public:
virtual Product* Create(ProductId);
};

Product* Creator::Create(ProductId id){
if(id == MINE) return new MyProduct;
if(id == YOURS) return new YourProduct;

return 0;
}

子类MyCreator可以重新定义工厂方法返回一个ConcreteProduct实例。

Product* MyProduct::Create(ProductId id){
if(id == MINE) return new YourProduct;
if(id == YOURS) return new MyProduct;
if(id == THEIRS) return new TheriProduct;
return Creator::Create(id);
}

有时，为了创建适当的Product对象，我们不得不创建一个Creator的子类。【可以使用模板子类进行解决】

四、实现例子：

1、工厂基类

Maze、Room、Wall、Door均为产品基类

class MazeGame(){
public:
Maze* CreatMaze();

virtual Maze* MakeMaze() const
{ return new Maze;}
virtual Room* MakeRoom(int n) const //工厂方法1
{ return new Room(n);}
virtual Wall* MakeWall() const //工厂方法2
{ return nre Wall;}
virtual Door* MakeDoor(Room* r1,Room* r2) const
{ return new Door(r1,r2);}
};

2、具体工厂类：

class BombedMazeGame: public MazeGame{
public:
BombedMazeGame();
virtual Wall* MakeWall() const //重新定义的工厂方法1
{ return new BombedWall;}
virtual Room* MakeRoom() const //重新定义的工厂方法2
{ return new* RoomWithABomb(n);}
}

注意体会与抽象工厂方法的不同，这里每一种产品的实现其实就是工厂模式。上例中具体工厂通过继承工厂基类，重新定义工厂方法，最终实现工厂模式。

比较有困惑的是CreateMaze函数的实现，其实这里主要是为了完整性考虑，CreateMaze函数不属于工厂方法中的参与者。

创建迷宫函数

Maze MazeGame::CreateMaze(){//该函数调用一系列产品基类函数来创建迷宫
Maze* aMaze = MakeMaze();

Room* r1 = MakeRoom(1);
Room* r2 = MakeRoom(2);
Door* theDoor = MakeDoor(r1,r2);

aMaze->AddRoom(r1);
aMaze->AddRoom(r2);

r1->SetSide(North,MakeWall());
r1->SetSide(East,theDoor);
r1->SetSide(South,MakeWall());
r1->SetSide(West,MakeWall());

r2->SetSide(North,MakeWall());
r2->SetSide(East,MakeWall());
r2->SetSide(South,MakeWall());
r2->SetSide(West,theDoor);
}