设计模式之创建型模式

1. 多线程安全的单例模式（double check）

class Locker
{
public:
    Locker()
    {
        pthread_mutex_init(&m_mutex, NULL);
    }

    ~Locker()
    {
        pthread_mutex_destroy(&m_mutex);
    }

    void lock()
    {
        pthread_mutex_lock(&m_mutex);
    }

    void unlock()
    {
        pthread_mutex_unlock(&m_mutex);
    }

private:
    pthread_mutex_t m_mutex;
};

template <typename T>
class Singleton
{
private:
    Singleton()
    {
    }

public:
    ~Singleton()
    {
    }

    /**
     * the only way to get the instance.
     * double check.
     */
    static T* getInstance()
    {
        if(NULL == m_instance)//once check
        {
            Locker m_lock;
            m_lock.lock();
            if(NULL == m_instance)//second check
            {
                m_instance = new T();
            }
            m_lock.unlock();
        }
        return m_instance;
    }

    static void destory()
    {
        Locker m_lock;
        m_lock.lock();
        if(NULL != m_instance)
        {
            delete m_instance;
            m_instance = NULL;
        }
        m_lock.unlock();
    }

private:
    static T* m_instance;
};

template<class T>
T* Singleton<T>::m_instance = NULL;

一些使用到的类

enum Direction {North, South, East, West};

class MapSite
{
public:
    virtual void Enter() = 0;
};

class Room: public MapSite
{
public:
    Room(int roomNo);
    MapSite *getSide(Direction) const;
    void setSide(Direction, MapSite*);
    virtual void Enter();

private:
    MapSite *_sides[4];
    int _roomNumber;
};

class Wall: public MapSite
{
public:
    Wall();
    virtual void Enter();
};

class Door: public MapSite
{
public:
    Door(Room *r1 = 0, Room *r2 = 0);

    virtual void Enter();
    Room* otherSideFrom(Room *);
private:
    Room *_room1;
    Room *_room2;
    bool _isOpen;
};

class Maze
{
public:
    Maze();
    void addRoom(Room *);
    Room* roomNo(int) const;
private:
    //...
    //
};


class MazeGame
{
public:
    MazeGame();
    Maze *createMaze();
private:
    //...
    //
};

2. 抽象工厂模式

class AbstractProductA
{

};

class AbstractProductB
{

};

class ProductA1: public AbstractProductA
{

};

class ProductA2: public AbstractProductA
{

};

class ProductB1: public AbstractProductB
{

};

class ProductB2: public AbstractProductB
{

};

class AbstractFactory
{
public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

class ConcreteFactory1
{
public:
    AbstractProductA* createProductA()
    {
        return new ProductA1();
    }

    AbstractProductB* createProductB()
    {
        return ProductB1();
    }
    
};

class ConcreteFactory2
{
public:
    AbstractProductA* createProductA()
    {
        return ProductA2();
    }

    AbstractProductB* createProductB()
    {
        return ProductB2();
    }
};

3. 生成器模式

class MazeBuilder
{
public:
    virtual void BuildMaze() { }
    virtual void BuildRoom(int roomNo) { }
    virtual void BuildDoor(int roomFrom, int roomTo) { }

    virtual Maze* getMaze() {
        return 0;
    }
protected:
    MazeBuilder();
};

class StandardMazeBuilder: public MazeBuilder
{
public:
    StandardMazeBuilder()
    {
        _currentMaze = 0;
    }
    virtual void BuildMaze(){
        _currentMaze = new Maze();
    }
    virtual void 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());
        }
    }
    virtual void 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(r1, r2), d);
    }

    virtual Maze* getMaze()
    {
        return _currentMaze;
    }

private:
    Direction commonWall(Room*, Room*);
    Maze* _currentMaze;
};

class MazeGame
{
public:
    Maze* createMaze(MazeBuilder &builder)
    {
        //hider the detail of how to create them.
        builder.BuildMaze();
        builder.BuildRoom(1);
        builder.BuildRoom(2);
        builder.BuildDoor(1, 2);
        return builder.getMaze();
    }

    Maze* createComplexMaze(MazeBuilder &builder)
    {
        builder.BuildMaze();
        builder.BuildRoom(1);
        builder.BuildRoom(2);
        //...
        builder.BuildRoom(1001);
        builder.BuildDoor(1, 2);
        return builder.getMaze();
    }
};

4. 工厂模式

//the factory
class MazeGame
{
public:
    MazeGame();
    Maze *createMaze();

    //factory methods
    virtual Maze* makeMaze() const
    {
        return new Maze();
    }
    virtual Room* makeRoom(int n) const{
        return new Room(n);
    }
    virtual Wall* makeWall() const {
        return new Wall();
    }
    virtual Door* makeDoor(Room* r1, Room* r2) const
    {
        return new Door(r1, r2);
    }
private:
    //...
    //
};

//the factory
class BombedMazeGame: public MazeGame
{
public:
    BombedMazeGame();
    virtual Wall* makeWall() const
    {
        return new BombedWall();
    }

    virtual Room* makeRoom(int n) const
    {
        return RoomWithBomb(n);
    }
};

//the factory
class EnchantedMazeGame: public MazeGame
{
public:
    EnchantedMazeGame();

    virtual Room* makeRoom(int n) const
    {
        return new EnchantedRoom(n, CastSpell());
    }

    virtual Door* makeDoor(Room *r1, Room *r2) const
    {
        return new DoorNeedingSpell(r1, r2);
    }

protected:
    Spell *CastSpell() const;
};


Maze* MazeGame::createMaze()
{
    Maze* aMaze = makeMaze();
    Room *r1 = makeRoom(1);//the room maybe child Room
    Room *r2 = makeRoom(2);
    Door *theDoor = makeDoor(r1, r1);//the door maybe child door
    //..
    return aMaze;
}

5. 原型模式

找工作的时候，我们需要准备简历。假设没有打印设备，因此需手写简历，这些简历的内容都是一样的。这样有个缺陷，如果要修改简历中的某项，那么所有已写好 的简历都要修改，工作量很大。随着科技的进步，出现了打印设备。我们只需手写一份，然后利用打印设备复印多份即可。如果要修改简历中的某项，那么修改原始 的版本就可以了，然后再复印。原始的那份手写稿相当于是一个原型，有了它，就可以通过复印（拷贝）创造出更多的新简历。

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

    virtual Maze* makeMaze() const;
    virtual Room* makeRoom(int) const;
    virtual Wall* makeWall() const
    {
        return _prototypeWall->Clone();
    }
    virtual Door* makeDoor(Room* r1, Room* r2) const
    {
        Door *d = _prototypeDoor->Clone();
        d->Initialize(r1, r2);
        return d;
    }

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

int main()
{
    MazePrototypeFactory simpleMazeFactory(new Maze(), new Wall(), new Room(), new Door());
    MazePrototypeFactory bombedMazeFactory(new Maze(), new BombedWall(), new RoomWithBomb(), new Door());
}