Chain Of Resoponsibility(职责链模式)

#ifndef HANDLER_H
#define HANDLER_H
#include <windows.h>

class Handler
{
    public:
        /** Default constructor */
        Handler(Handler* pHandler);
        /** Default destructor */
        virtual ~Handler();
        virtual void HandleRequest()=0;
        BOOL HaveSuccessor(){return NULL!=m_pSuccessor;}
    protected:
    private:
    Handler* m_pSuccessor;
};

#endif // HANDLER_H

#include "Handler.h"
#include <windows.h>
Handler::Handler(Handler* pHandler):m_pSuccessor(NULL)
{
    m_pSuccessor=pHandler;
}

Handler::~Handler()
{
    //dtor
}

void Handler::HandleRequest()
{
    if (NULL!=m_pSuccessor)
    {
        m_pSuccessor->HandleRequest();
    }
}

#ifndef CONCRETEHANDLERA_H
#define CONCRETEHANDLERA_H

#include "Handler.h"


class ConcreteHandlerA : public Handler
{
    public:
        /** Default constructor */
        ConcreteHandlerA(Handler* pHandler);
        /** Default destructor */
        virtual ~ConcreteHandlerA();
        void HandleRequest();
    protected:
    private:
};

#endif // CONCRETEHANDLERA_H

#include "ConcreteHandlerA.h"
#include <iostream>
using namespace std;

ConcreteHandlerA::ConcreteHandlerA(Handler* pHandler):Handler(pHandler)
{
    //ctor
}

ConcreteHandlerA::~ConcreteHandlerA()
{
    //dtor
}

void ConcreteHandlerA::HandleRequest()
{
    if (HaveSuccessor())
    {
        Handler::HandleRequest();
    }
    else
        cout<<"ConcreteHandlerA Handled Request"<<endl;
}

#ifndef CONCRETEHANDLERB_H
#define CONCRETEHANDLERB_H

#include "Handler.h"


class ConcreteHandlerB : public Handler
{
    public:
        /** Default constructor */
        ConcreteHandlerB(Handler* pHandler);
        /** Default destructor */
        virtual ~ConcreteHandlerB();
        void HandleRequest();
    protected:
    private:
};

#endif // CONCRETEHANDLERB_H

#include "ConcreteHandlerB.h"
#include <iostream>
using namespace std;

ConcreteHandlerB::ConcreteHandlerB(Handler* pHandler):Handler(pHandler)
{
    //ctor
}

ConcreteHandlerB::~ConcreteHandlerB()
{
    //dtor
}

void ConcreteHandlerB::HandleRequest()
{
     if (HaveSuccessor())
    {
        Handler::HandleRequest();
    }
    else
        cout<<"ConcreteHandlerB Handled Request"<<endl;
}

#include <iostream>
#include "Handler.h"
#include "ConcreteHandlerA.h"
#include "ConcreteHandlerB.h"
using namespace std;

int main()
{
    Handler* pHandlerA=new ConcreteHandlerA(NULL);
    Handler* pHandlerB=new ConcreteHandlerB(pHandlerA);
    pHandlerB->HandleRequest();
    delete pHandlerB;
    delete pHandlerA;
    return 0;
}