设计模式-中介者模式

shienh 2020年02月01日 285次浏览

中介者(Mediator)模式的定义:定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。中介者模式又叫调停模式,它是迪米特法则的典型应用。

#include <iostream>
using namespace std;

class Person;
class Mediator {
public:
    virtual void Send(const string& msg, Person* person) = 0;

    virtual ~Mediator() { }

    void BuildRelation(Person *a, Person *b) {
        m_a = a;
        m_b = b;
    }

protected:
    Person *m_a;
    Person *m_b;
};

class ConcreteMediator :public Mediator {
public:
    void Send(const string& msg, Person* person) {
        if (person == m_a) {
            cout << msg << "--Mediator--PersonB" << endl;
        }
        else if (person == m_b) {
            cout << msg << "--Mediator--PersonA" << endl;
        }
    }
};

class Person {
public:
    Person(Mediator*md):_md(md) { }
    virtual void SendMessage(const string& msg) = 0;
    virtual ~Person() { }
protected:
    Mediator* _md;
};

class ConcretePersonA :public Person {
public:
    ConcretePersonA(Mediator* md):Person(md) { }

    void SendMessage(const string& msg) {
        _md->Send(msg, this);
    }

};

class ConcretePersonB :public Person {
public:
    ConcretePersonB(Mediator* md):Person(md) { }

    void SendMessage(const string& msg) {
        _md->Send(msg, this);
    }
};

int main(int argc, char *argv[])
{
    Mediator *mediator = new ConcreteMediator();
    Person *personA = new ConcretePersonA(mediator);
    Person *personB = new ConcretePersonB(mediator);

    mediator->BuildRelation(personA, personB);
    personA->SendMessage("PersonA");
    personB->SendMessage("PersonB");

    delete personA;
    delete personB;
    delete mediator;
    return 0;
}