我与C++设计模式（十七）——中介者模式

Mediator模式就是起到一个同类对象之间进行通信交互的媒介作用，逻辑很简单，书上对这个模式的解释是最吝惜的了，如下UML图：

如图每个Colleague维护一个Mediator，ConcreteColleageA和ConcreteColleagueB之间要进行交互通信是就可以通过ConcreteMediator的DoActionFromAtoB和DoActionFromBtoA两个函数实现，而ConcreteColleagueA和ConcreteColleagueB之间没有直接关系了，即，他们的定义不涉及对方，或者说相互未知。

实现代码：

#ifndef _COLLEAGUE_H__
#define _COLLEAGUE_H__

#include <string>
using namespace std;

class mediator;

class colleague
{
        public:
                virtual ~colleague();
                virtual void action() = 0;
                virtual void set_state(const string&) = 0;
                virtual string get_state() = 0;

        protected:
                colleague();
                colleague(mediator *);
                mediator *_p_med;
};

class concrete_colleague_A:public colleague
{
        public:
                concrete_colleague_A();
                concrete_colleague_A(mediator *);
                ~concrete_colleague_A();
                void action();
                void set_state(const string &);
                string get_state();

        private:
                string _sta;
};

class concrete_colleague_B:public colleague
{
        public:
                concrete_colleague_B();
                concrete_colleague_B(mediator *);
                ~concrete_colleague_B();
                void action();
                void set_state(const string &);
                string get_state();

        private:
                string _sta;
};
#endif

//colleague.cpp

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

colleague::colleague()
        :_p_med(0)
{
}

colleague::colleague(mediator * p_med)
        :_p_med(p_med)
{
}

colleague::~colleague()
{
        if (_p_med)
        {
                delete _p_med;
                _p_med = NULL;
        }
}

//------------------A-------------------
concrete_colleague_A::concrete_colleague_A()
        :_sta("")
{
}

concrete_colleague_A::concrete_colleague_A(mediator *p_med)
        :colleague(p_med),_sta("")
{
}

concrete_colleague_A::~concrete_colleague_A()
{
}

string concrete_colleague_A::get_state()
{
        return _sta;
}

void concrete_colleague_A::set_state(const string & str)
{
        _sta = str;
}

void concrete_colleague_A::action()
{
        _p_med->do_action_from_A_to_B();
        cout<<"state of B: "<<get_state()<<endl;
};

//------------------B-------------------
concrete_colleague_B::concrete_colleague_B()
        :_sta("")
{
}

concrete_colleague_B::concrete_colleague_B(mediator *p_med)
        :colleague(p_med),_sta("")
{
}

concrete_colleague_B::~concrete_colleague_B()
{
}

string concrete_colleague_B::get_state()
{
        return _sta;
}

void concrete_colleague_B::set_state(const string & str)
{
        _sta = str;
}

void concrete_colleague_B::action()
{
        _p_med->do_action_from_B_to_A();
        cout<<"state of A: "<<get_state()<<endl;
};

#ifndef _MEDIATOR_H__
#define _MEDIATOR_H__

class colleague;

class mediator
{
        public:
                virtual ~mediator();
                virtual void do_action_from_A_to_B() = 0;
                virtual void do_action_from_B_to_A() = 0;

        protected:
                mediator();
};

class concrete_mediator:public mediator
{
        public:
                concrete_mediator();
                concrete_mediator(colleague *, colleague *);
                ~concrete_mediator();

                void set_concrete_colleague_A(colleague *);
                void set_concrete_colleague_B(colleague *);
                colleague *get_concrete_colleague_A();
                colleague *get_concrete_colleague_B();
                void intro_colleage(colleague *, colleague *);
                void do_action_from_A_to_B();
                void do_action_from_B_to_A();

        private:
                colleague *_p_clg_A;
                colleague *_p_clg_B;
};

#endif

//mediator.cpp

#include "mediator.h"
#include "colleague.h"

mediator::mediator()
{
}

mediator::~mediator()
{
}


concrete_mediator::concrete_mediator()
        :_p_clg_A(0),_p_clg_B(0)
{
}

concrete_mediator::concrete_mediator(colleague *p_clg_A, colleague *p_clg_B)
        :_p_clg_A(p_clg_A),_p_clg_B(p_clg_B)
{
}
concrete_mediator::~concrete_mediator()
{
        if (_p_clg_A)
        {
                delete _p_clg_A;
                _p_clg_A = NULL;
        }
        if (_p_clg_B)
        {
                delete _p_clg_B;
                _p_clg_B = NULL;
        }
}

void concrete_mediator::do_action_from_A_to_B()
{
        _p_clg_B->set_state(_p_clg_A->get_state());
}

void concrete_mediator::do_action_from_B_to_A()
{
        _p_clg_A->set_state(_p_clg_B->get_state());
}

void concrete_mediator::set_concrete_colleague_A(colleague *p_clg)
{
        _p_clg_A = p_clg;
}

void concrete_mediator::set_concrete_colleague_B(colleague *p_clg)
{
        _p_clg_B = p_clg;
}

colleague *concrete_mediator::get_concrete_colleague_A()
{
        return _p_clg_A;
}

colleague *concrete_mediator::get_concrete_colleague_B()
{
        return _p_clg_B;
}

void concrete_mediator::intro_colleage(colleague *p_clg_A,colleague *p_clg_B)
{
        _p_clg_A = p_clg_A;
        _p_clg_B = p_clg_B;
}

//main.cpp
#include "colleague.h"
#include "mediator.h"
#include <iostream>
using namespace std;

int main(int argc,char **argv)
{
        concrete_mediator *p_med = new concrete_mediator();
        colleague *p_clg_A = new concrete_colleague_A(p_med);
        colleague *p_clg_B = new concrete_colleague_B(p_med);
        p_med->intro_colleage(p_clg_A,p_clg_B);

        p_clg_A->set_state("jack");
        p_clg_B->set_state("jack");
        p_clg_A->action();
        p_clg_B->action();
        cout<<endl;

        p_clg_A->set_state("rose");
        p_clg_A->action();
        p_clg_B->action();
        cout<<endl;

        return 0;
}

结果：

$ ./mediator.exe
state of B: jack
state of A: jack

state of B: rose
state of A: rose