设计模式之职责链模式

优点：我没看懂。

体会：以父类为桥梁，派生类调用彼此的方法。

#pragma once
class Handle
{
public:
    virtual ~Handle();

    virtual void HandleRequest() = 0;

    void SetSuccessor(Handle *succ);

    Handle *GetSuccessor();

protected:
    Handle();

    Handle(Handle *succ);

private:
    Handle *m_succ;
};

#include "Handle.h"


Handle::Handle()
{
    m_succ = 0;
}


Handle::~Handle()
{
}

Handle::Handle(Handle *succ)
{
    this->m_succ = succ;
}

void Handle::SetSuccessor(Handle *succ)
{
    m_succ = succ;
    return;
}

Handle *Handle::GetSuccessor()
{
    return m_succ;
}

 

派生类A

#pragma once
#include "Handle.h"
class ConcreateHandleA :
    public Handle
{
public:
    ConcreateHandleA();

    ~ConcreateHandleA();

    ConcreateHandleA(Handle *succ);

    void HandleRequest();
};

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


ConcreateHandleA::ConcreateHandleA()
{
}

ConcreateHandleA::ConcreateHandleA(Handle *succ) : Handle(succ)
{
}


ConcreateHandleA::~ConcreateHandleA()
{
}

void ConcreateHandleA::HandleRequest()
{
    if (this->GetSuccessor() != 0)
    {
        std::cout << "ConcreateHandleA::HandleRequest...把处理权交给后继节点。。。" << std::endl;
        this->GetSuccessor()->HandleRequest();
    }
    else
    {
        std::cout << "ConcreateHandleA::HandleRequest...未发现后继节点，自己处理。。。" << std::endl;
    }
    return;
}

 

派生类B

#pragma once
#include "Handle.h"
class ConcreateHandleB :
    public Handle
{
public:
    ConcreateHandleB();

    ~ConcreateHandleB();

    ConcreateHandleB(Handle *succ);

    void HandleRequest();
};

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


ConcreateHandleB::ConcreateHandleB()
{
}

ConcreateHandleB::ConcreateHandleB(Handle *succ) : Handle(succ)
{
}


ConcreateHandleB::~ConcreateHandleB()
{
}

void ConcreateHandleB::HandleRequest()
{
    if (this->GetSuccessor() != 0)
    {
        std::cout << "ConcreateHandleB::HandleRequest... 把处理权交给后继节点。。。" << std::endl;
        this->GetSuccessor()->HandleRequest();
    }
    else
    {
        std::cout << "ConcreateHandleB::HandleRequest... 没有后继节点，自己处理" << std::endl;
    }
    return;
}

 

测试

#include <iostream>
#include "ConcreateHandleA.h"
#include "ConcreateHandleB.h"

int main()
{
    Handle *h1 = new ConcreateHandleA();

    Handle *h2 = new ConcreateHandleB();

    h1->SetSuccessor(h2);

    h1->HandleRequest();

    if (h2)
    {
        delete h2;
        h2 = NULL;
    }

    if (h1)
    {
        delete h1;
        h1 = NULL;
    }

    std::cout << "Hello World!\n"; 
}