中介者模式

一 应用场景
以房屋中介为例，租房者向中介询问租房信息，出租者向中介提供房子信息。

二 定义
中介者模式 Mediator Pattern：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

Mediator 抽象中介者：定义一个接口，用于各个对象之间的通信。

ConcreteMediator 具体中介者：抽象中介者的子类，通过协调各个同事对象来实现协作行为，维持各个对各个对象的引用。

Colleage 抽象同事类：定义各个对象的公有方法。同时维持一个对抽象中介类的引用，其对象可以通过该引用实现与中介通信。

ConcreteMediator 具体同事类：每个同事对象在通信的时候先与中介者通信，通过中介来完成与其他同事的通信

三 C++实现
Mediator.h

#pragma once 

#include <iostream>  
#include <string>

using namespace std;


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


class Mediator;

class Person
{
public:
    virtual void setMediator(Mediator * _mediator) = 0;

    virtual void sendMsg(std::string _msg) = 0;

    virtual void getMsg(std::string _msg) = 0;

protected:
    Mediator * mediator;
};

class Mediator
{
public:
    virtual void sendMsg(std::string _msg, Person * _person) = 0;

    virtual void setRenter(Person * _renter) = 0;

    virtual void setLandlord(Person * _landlord) = 0;
};

class Renter:public Person
{
public:
    void setMediator(Mediator * _mediator){
        mediator = _mediator;
    }

    void sendMsg(std::string _msg){
        mediator->sendMsg(_msg, this);
    }

    void getMsg(std::string _msg){
        std::cout << "msg from landlord: " << _msg << std::endl;
    }
};

class Landlord:public Person
{
public:
    void setMediator(Mediator * _mediator){
        mediator = _mediator;
    }

    void sendMsg(std::string _msg){
        mediator->sendMsg(_msg, this);
    }

    void getMsg(std::string _msg){
        std::cout << "msg from renter" << _msg << std::endl;
    }
};

class ConcreteMediator:public Mediator
{
public:
    ConcreteMediator():p_renter(NULL), p_landlord(NULL){}

    void sendMsg(std::string _msg, Person * _person){
        if(_person == p_renter){
            p_landlord->getMsg(_msg);
        } else if(_person==p_landlord){
            p_renter->getMsg(_msg);
        }
    }

    void setRenter(Person * _renter){
        p_renter = _renter;
    }

    void setLandlord(Person * _landlord){
        p_landlord = _landlord;
    }

private:
    Person * p_renter;
    Person * p_landlord;
};

main.cpp

#include <iostream>
#include <string>
#include <ostream>

#include "Mediator.h"

using namespace std;


int main()
{
    Mediator * mediator = new ConcreteMediator();
    Person * renter = new Renter();
    Person * landlord = new Landlord();
    mediator->setRenter(renter);
    mediator->setLandlord(landlord);

    renter->setMediator(mediator);
    landlord->setMediator(mediator);

    renter->sendMsg(std::string("I want to rent a hourse\n"));

    system("pause");
    return 0;
}

运行结果

四 总结
优点：
1 简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构转换成相对简单的星型结构。
2 中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合

缺点
1 在具体中介者类中包含了大量同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。