Les envío un nuevo ejemplo de cadena de responsabilidades, estos ejemplos los
estoy sacando de la página que les mostré en un post anterior, portando el código a c++.

#ifndef CONCRETEHANDLERA_DEF
#define CONCRETEHANDLERA_DEF

#include
#include "handler.h"

class CConcreteHandlerA : public CHandler
{
public:
CConcreteHandlerA();
virtual void handleRequest(int request);
virtual ~CConcreteHandlerA();

};

#endif // CONCRETEHANDLERA_DEF


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERB_DEF
#define CONCRETEHANDLERB_DEF

#include
#include "handler.h"

class CConcreteHandlerB : public CHandler
{
public:
CConcreteHandlerB();
virtual void handleRequest(int request);
virtual ~CConcreteHandlerB();

};

#endif // CONCRETEHANDLERB_DEF


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERC_DEF
#define CONCRETEHANDLERC_DEF

#include
#include "handler.h"

class CConcreteHandlerC : public CHandler
{
public:
CConcreteHandlerC();
virtual void handleRequest(int request);
virtual ~CConcreteHandlerC();

};

#endif // CONCRETEHANDLERC_DEF


//---------------------------------------------------------------------

#ifndef HANDLER_DEF
#define HANDLER_DEF

class CHandler
{
protected:
CHandler * m_successor;

public:
void setSuccessor(CHandler * successor);
virtual void handleRequest(int request);
};

#endif //HANDLER_DEF


#ifndef CONCRETEHANDLERA_IMP
#define CONCRETEHANDLERA_IMP


//---------------------------------------------------------------------

#include "ConcreteHandlerA.h"

CConcreteHandlerA::CConcreteHandlerA()
{

}

CConcreteHandlerA::~CConcreteHandlerA()
{

}

void CConcreteHandlerA::handleRequest(int request)
{
if (request >= 10 && request < 20)
{
std::cout << "ConcreteHandlerA handled request: " << request;
}
else if (m_successor != 0)
{
m_successor->handleRequest(request);
}
}

#endif //CONCRETEHANDLERA_IMP


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERB_IMP
#define CONCRETEHANDLERB_IMP

#include "ConcreteHandlerB.h"

CConcreteHandlerB::CConcreteHandlerB()
{

}

CConcreteHandlerB::~CConcreteHandlerB()
{

}

void CConcreteHandlerB::handleRequest(int request)
{
if (request >= 10 && request < 20)
{
std::cout << "ConcreteHandlerC handled request: " << request;
}
else if (m_successor != 0)
{
m_successor->handleRequest(request);
}
}

#endif //CONCRETEHANDLERB_IMP


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERC_IMP
#define CONCRETEHANDLERC_IMP

#include "ConcreteHandlerC.h"

CConcreteHandlerC::CConcreteHandlerC()
{

}

CConcreteHandlerC::~CConcreteHandlerC()
{

}

void CConcreteHandlerC::handleRequest(int request)
{
if (request >= 10 && request < 20)
{
std::cout << "ConcreteHandlerC handled request: " << request;
}
else if (m_successor != 0)
{
m_successor->handleRequest(request);
}
}

#endif //CONCRETEHANDLER_IMP


//---------------------------------------------------------------------


#ifndef HANDLER_IMP
#define HANDLER_IMP

#include "handler.h"

void CHandler::setSuccessor(CHandler * successor)
{
this->m_successor = successor;
}

#endif //HANDLER_IMP


//---------------------------------------------------------------------
#include
#include "handler.h"
#include "concretehandlera.h"
#include "concretehandlerb.h"
#include "concretehandlerc.h"

int main()
{
std::cout << ":This is a Chain of responsibility example:";
// Setup Chain of Responsibility
CHandler * h1 = new CConcreteHandlerA();
CHandler * h2 = new CConcreteHandlerB();
CHandler * h3 = new CConcreteHandlerC();
h1->setSuccessor(h2);
h2->setSuccessor(h3);

// Generate and process request
int requests[] = {2, 5, 14, 22, 18, 3, 27, 20};

for (int i=0; i < sizeof(requests); i++)
{
h1->handleRequest(requests[i]);
}
return 0;
}