设计模式之中介者模式

中介者基类

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

    virtual void DoActionFromAtoB() = 0;

    virtual void DoActionFromBtoA() = 0;

protected:
    Mediator();
};

#include "Mediator.h"


Mediator::Mediator()
{
}


Mediator::~Mediator()
{
}

 

中介者派生类

#pragma once
#include "Mediator.h"

class Colleage;

class ConcreateMediator :
    public Mediator
{
public:
    ConcreateMediator();
    ~ConcreateMediator();

    ConcreateMediator(Colleage *clgA, Colleage *clgB);

    void SetConcreateColleageA(Colleage *clgA);

    void SetConcreateColleageB(Colleage *clgB);

    Colleage *GetConcreateColleageA();

    Colleage *GetConcreateColleageB();

    void IntroColleage(Colleage *clgA, Colleage *clgB);

    void DoActionFromAtoB();

    void DoActionFromBtoA();

private:
    Colleage *m_clgA;
    Colleage *m_clgB;
};

#include "ConcreateMediator.h"
#include "ConcreateColleageA.h"
#include "ConcreateColleageB.h"


ConcreateMediator::ConcreateMediator()
{
}


ConcreateMediator::~ConcreateMediator()
{
}

ConcreateMediator::ConcreateMediator(Colleage *clgA, Colleage *clgB)
{
    this->m_clgA = clgA;
    this->m_clgB = clgB;
}

void ConcreateMediator::SetConcreateColleageA(Colleage *clgA)
{
    this->m_clgA = clgA;
}

void ConcreateMediator::SetConcreateColleageB(Colleage *clgB)
{
    this->m_clgB = clgB;
}

Colleage *ConcreateMediator::GetConcreateColleageA()
{
    return m_clgA;
}

Colleage *ConcreateMediator::GetConcreateColleageB()
{
    return m_clgB;
}

void ConcreateMediator::IntroColleage(Colleage *clgA, Colleage *clgB)
{
    this->m_clgA = clgA;
    this->m_clgB = clgB;
    return;
}

void ConcreateMediator::DoActionFromAtoB()
{
    m_clgB->SetState(m_clgA->GetState());
    return;
}

void ConcreateMediator::DoActionFromBtoA()
{
    m_clgA->SetState(m_clgB->GetState());
    return;
}

 

通信基类

#pragma once
#include <string>

class Mediator;

class Colleage
{
public:
    virtual ~Colleage();

    virtual void Action() = 0;

    virtual void SetState(const std::string &state) = 0;

    virtual std::string GetState() = 0;

protected:
    Colleage();

    Colleage(Mediator *media);

    Mediator *m_media;

};

#include "Colleage.h"
#include "Mediator.h"


Colleage::Colleage()
{
}


Colleage::~Colleage()
{
}

Colleage::Colleage(Mediator *media)
{
    this->m_media = media;
}

 

派生通信类A

#pragma once
#include "Colleage.h"

class Mediator;

class ConcreateColleageA :
    public Colleage
{
public:
    ConcreateColleageA();
    ~ConcreateColleageA();

    ConcreateColleageA(Mediator *media);

    void Action();

    void SetState(const std::string &state);

    std::string GetState();

private:
    std::string m_state;
};

#include "ConcreateColleageA.h"
#include "ConcreateMediator.h"
#include <iostream>


ConcreateColleageA::ConcreateColleageA()
{
}


ConcreateColleageA::~ConcreateColleageA()
{
}

ConcreateColleageA::ConcreateColleageA(Mediator *media) : Colleage(media)
{
}

std::string ConcreateColleageA::GetState()
{
    return m_state;
}

void ConcreateColleageA::SetState(const std::string &state)
{
    m_state = state;
    return;
}

void ConcreateColleageA::Action()
{
    m_media->DoActionFromAtoB();
    std::cout << "State of ConcreateColleageB:" << this->GetState() << std::endl;
    return;
}

 

通信派生类B

#pragma once
#include "Colleage.h"

class Mediator;

class ConcreateColleageB :
    public Colleage
{
public:
    ConcreateColleageB();
    ~ConcreateColleageB();

    ConcreateColleageB(Mediator *media);

    void Action();

    void SetState(const std::string &state);

    std::string GetState();

private:
    std::string m_state;
};

#include "ConcreateColleageB.h"
#include "ConcreateMediator.h"
#include <iostream>


ConcreateColleageB::ConcreateColleageB()
{
}


ConcreateColleageB::~ConcreateColleageB()
{
}


ConcreateColleageB::ConcreateColleageB(Mediator *media) : Colleage(media)
{

}

void ConcreateColleageB::Action()
{
    m_media->DoActionFromBtoA();
    std::cout << "State of ConcreateB:" << this->GetState() << std::endl;
    return;
}

void ConcreateColleageB::SetState(const std::string &state)
{
    m_state = state;
    return;
}

std::string ConcreateColleageB::GetState()
{
    return m_state;
}

 

测试

#include <iostream>
#include "ConcreateMediator.h"
#include "ConcreateColleageA.h"
#include "ConcreateColleageB.h"

int main()
{
    ConcreateMediator *media = new ConcreateMediator();

    ConcreateColleageA *clg1 = new ConcreateColleageA(media);

    ConcreateColleageB *clg2 = new ConcreateColleageB(media);

    media->IntroColleage(clg1, clg2);

    clg1->SetState("old");
    clg2->SetState("old");

    clg1->Action();
    clg2->Action();

    std::cout << "-------------" << std::endl;

    clg1->SetState("new");
    clg1->Action();    // clg1把new给clg2, clg2状态变为new
    clg2->Action();
    std::cout << "-------------" << std::endl;

    clg2->SetState("old");
    clg2->Action();    // clg2把old给clg1, clg1状态变为old
    clg1->Action();

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

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

    if (clg2)
    {
        delete clg2;
        clg2 = NULL;
    }
    std::cout << "Hello World!\n"; 
}