[行为型模式] 中介者模式的理解

头文件

//MediatorPattern.h

#ifndef MEDIATOR_PATTERN_H
#define MEDIATOR_PATTERN_H

#include <Windows.h>
#include <iostream>
using namespace std;

namespace MediatorPattern
{
    class Mediator;
    class Colleague
    {
    public:
        Colleague(Mediator* pMediator);
        virtual void Send(const char* pszMsg) = 0;
        virtual void Notify(const char* pszMsg) = 0;

    protected:
        Mediator* m_pMediator;
    };

    class ConcreteColleagueA : public Colleague
    {
    public:
        ConcreteColleagueA(Mediator* pMediator);
        virtual void Send(const char* pszMsg);
        virtual void Notify(const char* pszMsg);
    };

    class ConcreteColleagueB : public Colleague
    {
    public:
        ConcreteColleagueB(Mediator* pMediator);
        virtual void Send(const char* pszMsg);
        virtual void Notify(const char* pszMsg);
    };

    //////////////////////////////////////////////////////////////////////////
    class Mediator
    {
    public:
        virtual void Send(const char* pszMsg, Colleague* pColleague) = 0;
    };

    class ConcreteMediator : public Mediator
    {
    public:
        virtual void Send(const char* pszMsg, Colleague* pColleague);

        void SetColleagueA(Colleague* pColleague);
        void SetColleagueB(Colleague* pColleague);

    private:
        // The Mediator knows all the Colleague
        ConcreteColleagueA* m_pConcreteColleagueA;
        ConcreteColleagueB* m_pConcreteColleagueB;
    };

    //////////////////////////////////////////////////////////////////////////
    void MediatorPattern_Test();
}

#endif

实现

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

#define SAFE_DELETE(p) if (p) { delete p; p = NULL; }

namespace MediatorPattern
{
    //////////////////////////////////////////////////////////////////////////
    Colleague::Colleague(Mediator* pMediator)
        : m_pMediator(pMediator)
    {
        cout << "Colleague::Colleague" << endl;
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteColleagueA::ConcreteColleagueA(Mediator* pMediator)
        : Colleague(pMediator)
    {
        cout << "ConcreteColleagueA::ConcreteColleagueA" << endl;
    }

    void ConcreteColleagueA::Send(const char* pszMsg)
    {
        cout << "ConcreteColleagueA::Send" << endl;
        cout << "Send request to Mediator:" << pszMsg << endl;
        m_pMediator->Send(pszMsg, this);
    }

    void ConcreteColleagueA::Notify(const char* pszMsg)
    {
        cout << "ConcreteColleagueA::Notify " << endl;
        cout << "Receive response from Mediator:" << pszMsg << endl;
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteColleagueB::ConcreteColleagueB(Mediator* pMediator)
        : Colleague(pMediator)
    {
        cout << "ConcreteColleagueA::ConcreteColleagueB" << endl;
    }

    void ConcreteColleagueB::Send(const char* pszMsg)
    {
        cout << "ConcreteColleagueB::Send" << endl;
        cout << "Send request to Mediator:" << pszMsg << endl;
        m_pMediator->Send(pszMsg, this);
    }

    void ConcreteColleagueB::Notify(const char* pszMsg)
    {
        cout << "ConcreteColleagueB::Notify " << endl;
        cout << "Receive response from Mediator:" << pszMsg << endl;
    }

    //////////////////////////////////////////////////////////////////////////
    void ConcreteMediator::Send(const char* pszMsg, Colleague* pColleague)
    {
        cout << "ConcreteMediator::Send -> GetMessage:" << pszMsg << endl;

        ConcreteColleagueA* pTemp = dynamic_cast<ConcreteColleagueA*>(pColleague);
        if (NULL == pTemp)
        {
            cout<<"The message is from ConcreteColleagueA. Now mediator forward it to ConcreteColleagueB"<<endl;
            if (m_pConcreteColleagueB != NULL)
            {
                pTemp->Notify("[ConcreteColleagueB]ConcreteMediator::Send->Notify");
            }
        }
        else
        {
            if (m_pConcreteColleagueA != NULL)
            {
                pTemp->Notify("[ConcreteColleagueA]ConcreteMediator::Send->Notify");
            }
        }
    }

    void ConcreteMediator::SetColleagueA(Colleague* pColleague)
    {
        m_pConcreteColleagueA = dynamic_cast<ConcreteColleagueA*>(pColleague);
    }

    void ConcreteMediator::SetColleagueB(Colleague* pColleague)
    {
        m_pConcreteColleagueB = dynamic_cast<ConcreteColleagueB*>(pColleague);
    }

    //////////////////////////////////////////////////////////////////////////
    void MediatorPattern_Test()
    {
        // Create the mediator
        Mediator *pMediator = new ConcreteMediator();

        Colleague *pColleague1 = new ConcreteColleagueA(pMediator);
        Colleague *pColleague2 = new ConcreteColleagueB(pMediator);

        ConcreteMediator *pConcreteMediator = dynamic_cast<ConcreteMediator *>(pMediator);
        pConcreteMediator->SetColleagueA(pColleague1);
        pConcreteMediator->SetColleagueB(pColleague2);

        char message[260] = "Where are you from?";
        pColleague1->Send(message);
    }
}

客户端

#include "MediatorPattern.h"

#include <iostream>
#include <sstream>
#include <string>
#include <list>
using namespace std;
using namespace VisitorPattern;

void main()
{
    MediatorPattern_Test();
}

运行结果