国产美女亚洲精品久久久综合 ,成人久久免费网站,欧美国产精品久久高清

常见设计模式的解析和实现(C++)之十�?Command模式

��王 — Thu, 04 Aug 2011 17:50:00 GMT

转：http://www.shnenglu.com/converse/archive/2006/08/04/10855.html

作用:
��一个请求封装�ؓ一个对�?从而��你可用不同的��h��对客戯��行参数化;对请求排队或记录��h��日志,以及支持可撤消的操作.
UML�l�构�?

解析:
Comnand模式的思想是把命��o��装在一个类�?��是�q�里的Command基类,同时把接收对象也��装在一个类中就是这里的Receiver�c�M��,��p��用这个命令的�c�M��是�q�里的Invoker�c�L��调用.其实,如果弄清楚了Command模式的原�?��׃��发现其实它和注册回调函数的原理是很相似的,而在面向�q�程的设计中的回调函数其实和�q�里的Command�cȝ��作用是一致的.采用Command模式解耦了命��o的发��和命��o的执行�?

实现:
1)Command.h

/********************************************************************
    created:    2006/08/04
    filename:     Command.h
    author:        李创
                http://www.shnenglu.com/converse/

    purpose:    Command模式的演�C�Z��?br />*********************************************************************/

#ifndef COMMAND_H
#define COMMAND_H

class Command
{
public:
    virtual ~Command() {}

    virtual void Execute() = 0;
};

class Receiver
{
public:
    void Action();
};

class Invoker
{
public:
    Invoker(Command *pCommand);
    ~Invoker();

    void Invoke();
private:
    Command *m_pCommand;
};

class ConcreateComand
    : public Command
{
public:
    ConcreateComand(Receiver* pReceiver);
    virtual ~ConcreateComand();

    virtual void Execute();

private:
    Receiver* m_pReceiver;
};

#endif

2)Command.cpp

/********************************************************************
    created:    2006/08/04
    filename:     Command.cpp
    author:        李创
                http://www.shnenglu.com/converse/

    purpose:    Command模式的演�C�Z��?br />*********************************************************************/

#include "Command.h"
#include <iostream>

void Receiver::Action()
{
    std::cout << "Receiver Action\n";
}

Invoker::Invoker(Command *pCommand)
    : m_pCommand(pCommand)
{

}

Invoker::~Invoker()
{
    delete m_pCommand;
    m_pCommand = NULL;
}

void Invoker::Invoke()
{
    if (NULL != m_pCommand)
    {
        m_pCommand->Execute();
    }
}

ConcreateComand::ConcreateComand(Receiver* pReceiver)
    : m_pReceiver(pReceiver)
{

}

ConcreateComand::~ConcreateComand()
{
    delete m_pReceiver;
    m_pReceiver = NULL;
}

void ConcreateComand::Execute()
{
    if (NULL != m_pReceiver)
    {
        m_pReceiver->Action();
    }

    std::cout << "Execute by ConcreateComand\n";
}

3)Main.cpp

/********************************************************************
    created:    2006/08/04
    filename:     main.cpp
    author:        李创
                http://www.shnenglu.com/converse/

    purpose:    Command模式的测试代�?br />*********************************************************************/

#include "Command.h"
#include <stdlib.h>

int main()
{
    Receiver* pReceiver = new Receiver();
    Command*  pCommand  = new ConcreateComand(pReceiver);
    Invoker*  pInvoker  = new Invoker(pCommand);

    pInvoker->Invoke();

    delete pInvoker;

    system("pause");

    return 0;
}

��王 2011-08-05 01:50 发表评论

常见设计模式的解析和实现(C++)之十�?ChainOfResponsibility模式

��王 — Thu, 04 Aug 2011 17:46:00 GMT

转：http://www.shnenglu.com/converse/archive/2006/07/28/10663.html

作用:
使多个对象都有机会处理请�?从而避免请求的发送者和接收者之间的耦合关系.��这些对象连成一条链�Q��ƈ沿着�q�条链传递该��h��,直到有一个对象处理它为止.

UML�l�构�?

抽象基类:
1)Handler:定义一个处理请求的接口,在图中这个接口就是HandleRequset函数,�q�个�c�d��时有一个指向Handler对象的指�?指向后箋的处理请求的对象(如果有的�?.

解析:
�q�个模式把可以处理一个请求的对象以链的�Ş式连在了一�?让这些对象都有处理请求的��Z��.好比原来看古装电视中�l�常看到皇宫中召见某人的时�?太监�?可以处理一个请求的对象)��׃��依次的喊:传XX...�q�样一直下�ȝ��到找到这个�h为止.ChainOfResponsibility模式也是�q�样的处理请求的,如果有后�l�的对象可以处理,那么传给后箋的对象处�?否则��p��己处理请�?�q�样的设计把��h��的发送者和��h��q�种的处理者解耦了,好比发号的皇帝不知道到底是哪个太监最后会扑ֈ�他要扑ֈ�的�h一�?只管发出命��o��OK�?

实现:
1)ChainOfResponsibility.h

/********************************************************************
    created:    2006/07/20
    filename:     ChainOfResponsibility.h
    author:        李创
                http://www.shnenglu.com/converse/

    purpose:    ChainOfResponsibility模式的演�C�Z��?br />*********************************************************************/

#ifndef CHAINOFRESPONSIBILITY_H
#define CHAINOFRESPONSIBILITY_H

#include <stdio.h>

// 抽象基类,定义一个处理请求的接口
class Handler
{
public:
    Handler(Handler *pSuccessor = NULL);
    virtual ~Handler();

    // �U�虚函数,由派生类实现
    virtual void HandleRequset() = 0;

protected:
    Handler* m_pSuccessor;
};

class ConcreateHandler1
    : public Handler
{
public:
    ConcreateHandler1(Handler *pSuccessor = NULL) : Handler(pSuccessor){}
    virtual ~ConcreateHandler1(){}

    virtual void HandleRequset();
};

class ConcreateHandler2
    : public Handler
{
public:
    ConcreateHandler2(Handler *pSuccessor = NULL) : Handler(pSuccessor){}
    virtual ~ConcreateHandler2(){}

    virtual void HandleRequset();
};

#endif

2)ChainOfResponsibility.cpp

/********************************************************************
    created:    2006/07/20
    filename:     ChainOfResponsibility.cpp
    author:        李创
                http://www.shnenglu.com/converse/

    purpose:    ChainOfResponsibility模式的演�C�Z��?br />*********************************************************************/

#include "ChainOfResponsibility.h"
#include <iostream>

Handler::Handler(Handler *pSuccessor /* = NULL*/)
    : m_pSuccessor(pSuccessor)
{
}

Handler::~Handler()
{
    delete m_pSuccessor;
    m_pSuccessor = NULL;
}

void ConcreateHandler1::HandleRequset()
{
    if (NULL != m_pSuccessor)
    {
        m_pSuccessor->HandleRequset();
    }
    else
    {
        std::cout << "HandleRequset by ConcreateHandler1\n";
    }
}

void ConcreateHandler2::HandleRequset()
{
    if (NULL != m_pSuccessor)
    {
        m_pSuccessor->HandleRequset();
    }
    else
    {
        std::cout << "HandleRequset by ConcreateHandler2\n";
    }
}

3)Main.cpp

/********************************************************************
    created:    2006/07/20
    filename:     Main.cpp
    author:        李创
                http://www.shnenglu.com/converse/

    purpose:    ChainOfResponsibility模式的测试代�?br />*********************************************************************/

#include "ChainOfResponsibility.h"
#include <stdlib.h>

int main()
{
    Handler *p1 = new ConcreateHandler1();
    Handler *p2 = new ConcreateHandler2(p1);

    p2->HandleRequset();

    delete p2;

    system("pause");

    return 0;
}

��王 2011-08-05 01:46 发表评论

Command模式

��王 — Sat, 16 Jan 2010 08:27:00 GMT

��王 2010-01-16 16:27 发表评论

Adapter模式

��王 — Sat, 16 Jan 2010 06:42:00 GMT

��王 2010-01-16 14:42 发表评论

Facade模式

��王 — Sat, 16 Jan 2010 06:32:00 GMT

没��用Facade模式前的�E�序�l�构�Q?br>

使用Facade模式后的�E�序�l�构�Q?br>

��王 2010-01-16 14:32 发表评论

抽象工厂(Abstract Factory)

��王 — Thu, 01 Jan 2009 20:23:00 GMT

摘要: 描述: 抽象工厂是一个适用于创��Z��p�d��相关的��品的创徏性模�?比如设计模式书中�l�常讲的那个例子-支持多视感窗口的工具�?比如windows和motif风格,�q�个是风格族.每种风格下面都有些标准的产品�?象BUTTON, TextBox, ListBox�{?试想一�?如果直接在client中指定具体��品和它的风格,那么会出�?*3 = 6中组�?如果�?.. 阅读全文

��王 2009-01-02 04:23 发表评论

��王 — Thu, 01 Jan 2009 20:22:00 GMT

一�Q?span> 工厂�Ҏ��Q�factory-method�Q�模�?/span>

1�Q?span> 意图

定义一个创建对象的接口�Q�让子类军_��实例化哪个��品类。工厂方法��一个对象的创徏延迟到子�c�R�?/span>

2�Q?span> 适用�?/span>

当一个类不知道它要创建的对象的类时�?/span>

当一个类希望由它的子�c�L��军_��创徏哪个�cȝ��对象时�?/span>

当一个类军_��创建对象委托给多个子类�Q��ƈ且希望将那个子类是代理这一信息局部化的时候�?/span>

3�Q?span> �l�构

4�Q?span> 参与�?/span>

l Creater�Q?/span>

声明工厂�Ҏ��的抽象类�Q�工厂方法返回一个��品类�Q?/span>Product�Q��?/span>

可以调用工厂�Ҏ��q�回一个��品对象�?/span>

l ConcreteCreater�Q?/span>

重定义工厂方法，以返回一个特定的product�?/span>

l Product:

产品抽象�c�，�l�用��h��供一致的产品接口�?/span>

l ConcreteProduct:

特定的��品，实现product接口�?/span>

5�Q?span> 效果

工厂�Ҏ��特定的�cȝ��实例化�g�q�到子类�Q�而且�q�回product接口�Q��用户代码不用和具体类打交道，一致的对待Product。所以在用户要加入新产品的时候，无需更改客户代码�Q�只需加入一个新�?/span>ConcreteProduct�?/span>ConcreteCreater卛_��Q�这个也是遵守了“开攑ְ�闭原�?#8221;�?/span>

�q�接�q��的类层次�Q�上面的�l�构图中�Q?/span>ConcreteCreater1对应�?/span>ConcreterProduct1�?/span>ConcreteCreater2对应创徏ConcreterProduct2。所�?/span>creater�?/span>product的类层次是��^行的�Q�用户只需选定一�?/span>Creater�Q�就创徏出对�?/span>product。像是一�?/span>map一��P��不会出现牛头不对马嘴之态�?/span>

6�Q?span> 实现及变�?/span>

Creater有两�U�实玎ͼ�一�U�就是抽象的工厂�Ҏ��Q�具体实现留到子�c�R��另一�U�就是有一个缺省的实现�Q�子�c�M��可以重新实现�q�个�Ҏ��。这�U�方法��用于真的有一个默认的Product需要实例化的这�U�情��c�?/span>

带参数的工厂�Ҏ��Q�这�U�情况可以创建多�U��品，不过有个限制��是所有��品都要实�?/span>product接口�Q�否则就失去工厂�Ҏ��的意义了。代码如下：

Product* ConcreteCreater1::FactoryMethod(int nID)

{

If(nID == BUTTON)

{

return new button;

}

Else if(nID == BOX)

{

return new box;

}

…

}

用模板实玎ͼ�省略创徏子类�?/span>

class Creater

{

public:

virtual Product* FactoryMethod() = 0;

};

template

class TempCreater: public Creater

{

virtual Product* FactoryMethod();

};

template

Product* TempCreater::FactoryMethod()

{

return new theProduct;

}

使用�q�个模版客户端只需定义产品�Q�而不需定义creater的子�c�R�?/span>

二． �E�序举例

在一�?/span>ACT游戏中，主角�q�关�q�程中有许多敌�h�Q�如��|��wolf�Q?/span>,蝙蝠�Q?/span>bat�Q?/span>,老怪（BOSS�Q?/span>,在每一关的刚开始就要创��多不同的敌�h�Q�如果不用工厂方法，则把所有的创徏��d��都放在了客户代码中，则一个代码不易扩充和修改�Q�二是代码很杂�ؕ。而用了工厂方法则可以克服�q�两个缺炏V��比如你增加一个新的敌�?/span>-恐龙�Q�则只需增加一个恐龙类�Q?/span>ConcreteProduct�Q�，再增加一个创建恐龙的�c�（ConcreteCreater �Q�就OK了�?br>

源码如下�Q?/span>

//product abstract class

class Enemy
{
public:
    virtual void attack() = 0;
    virtual void Draw() = 0;
    virtual ~Enemy() = 0;
};

// concrete product class
class Wolf : public Enemy
{
    void attack()
    {
        cout << "Wolf attack me!" << endl;
    }
    void Draw()
    {
        cout << "I am Wolf!" << endl;
    }
};

// concrete product class
class Bat : public Enemy
{
    void attack()
    {
        cout << "Bat attack me!" << endl;
    }
    void Draw()
    {
        cout << "I am Bat!" << endl;
    }
};

// concrete product class
class Boss : public Enemy
{
    void attack()
    {
        cout << "Boss attack me!" << endl;
    }
    void Draw()
    {
        cout << "I am Boss!" << endl;
    }
};

// creater abstract class
class EnemyCreater
{
    virtual Enemy* CreateEnemy() = 0;
};

// concrete creater class
class WolfCreater : public EnemyCreater
{
     Enemy* CreateEnemy()
     {
         return new Wolf;
     }
};

// concrete creater class
class BatCreater : public EnemyCreater
{
     Enemy* CreateEnemy()
     {
         return new Bat;
     }
};

// concrete creater class
class BossCreater : public EnemyCreater
{
     Enemy* CreateEnemy()
     {
         return new Boss;
     }
};

int main(int argc, char* argv[])
{
    EnemyCreater* enemyCreater[3];
    enemyCreater[0] = new WolfCreater;
    enemyCreater[1] = new BatCreater;
    enemyCreater[2] = new BossCreater;
    Enemy* cruEnemy = NULL;
    for(int i  = 0; i < 3; ++i)
    {
        cruEnemy = enemyCreater[i].CreateEnemy();

        cruEnemy->Draw();
        cruEnemy->attack();

        delete cruEnemy;
    }
    return 0;
}

三．相关模式

Abstract Factory�l�常用工厂方法来实现�?/span>

工厂�Ҏ��通常�?/span>Template Methods中被调用�?/span>

Prototypes不需要创�?/span>Creater的子�c�R��但是，它们通常要求一个针�?/span>Product�cȝ��Initialize操作�?/span>Creater使用Initialize来初始化对象。�?/span>Factory Method不需要这��L��操作�?/span>

四．参考文�?/span>

�?font size=3>设计模式�_�解�?/font> 清华大学出版�C�，熊杰译�?/span>

《设计模式可复用面向对象软�g的基��?/span> 机械工业出版�C�，四�h团著�?/span>

��王 2009-01-02 04:22 发表评论