设计模式简单代码之Mediator模式（一）

Mediator:中介者模式，当多个对象彼此间都有联系的时候，我们就可以应用Mediator将对象间的多对多关系转换为
一对多的关系，这样做，可以使各个对象间的耦合松散。统一管理对象间的通信协议。但也可能使得Mediator对象
成为一个系统中的庞然大物，难以维护。

好，我们现在来看一个实例。下面有三个对象：A,B,C。他们之间的关系是相互的，每个对象都知道其余的两个对象，都可以和其余的对象打交道。

我们先看看不使用Mediator模式的代码，这样的代码可能会产生混乱。 

// A.H  类A 的头文件，下面的类B和类C的结构相同，只是为了演示出三个类之间“纠缠不清”的关系

#ifndef _A_H
#define  _A_H

class  B;
class  C;

class  A
... {
public:
    void SetColleage(B *b, C *c);    // 设置同事（协助者），也就是需要打交道的对象
    void ACallB();                    // 调用协助者B的服务
    void ACallC();                    // 调用协助者C的服务
    void Function();                // 自己本身的服务
private:
    B *_b;
    C *_c;
} ;

#endif

// A.CPP

#include  " a.h "
#include  " b.h "
#include  " c.h "

#include  < iostream >
using   namespace  std;

void  A::SetColleage(B  * b, C  * c)
... {
    _b = b;
    _c = c;
}

void  A::ACallB()
... {
    cout << "A call ";
    _b->Function();
}

void  A::ACallC()
... {
    cout << "A call ";
    _c->Function();
}

void  A::Function()
... {
    cout << "A's Func!" << endl;
}

下面的B.H、B.CPP、C.H、C.CPP都和上面两个文件相似，下面给出这4个文件的完整内容

// B.H

#ifndef _B_H
#define  _B_H

class  A;
class  C;

class  B
... {
public:
    void SetColleage(A *a, C *c);
    void BCallA();
    void BCallC();
    void Function();

private:
    A *_a;
    C *_c;    
} ;

#endif

 // B.CPP

#include  " a.h "
#include  " b.h "
#include  " c.h "

#include  < iostream >
using   namespace  std;

void  B::SetColleage(A  * a, C  * c)
... {
    _a = a;
    _c = c;
}
void  B::BCallA()
... {
    cout << "B call ";
    _a->Function();
}
void  B::BCallC()
... {
    cout << "B call ";
    _c->Function();
}

void  B::Function()
... {
    cout << "B's Func!" << endl;
}

// C.H

#ifndef _C_H
#define  _C_H

class  A;
class  B;

class  C
... {
public:
    void SetColleage(A *a, B *b);
    void CCallA();
    void CCallB();
    void Function();

private:
    A *_a;
    B *_b;
} ;

#endif

// C.CPP

#include  " a.h "
#include  " b.h "
#include  " c.h "

#include  < iostream >
using   namespace  std;


void  C::SetColleage(A  * a, B  * b)
... {
    _a = a;
    _b = b;
}
void  C::CCallA()
... {
    cout << "C call ";
    _a->Function();
}
void  C::CCallB()
... {
    cout << "C call ";
    _b->Function();
}

void  C::Function()
... {
    cout << "C's Func!" << endl;
}

从上面三个类可以看出来，他们之间彼此都有关系，都可以和另外两个类对象打交道。在现实的软件系统中也可能会出现这种情况，整个系统的类间都有耦合性，最终导致整个系统变成一个耦合性很强的系统，完全没有重用可言。由于这种弊端，我们可以运用Mediator模式来解耦，这属于下篇文章的内容，现在我们先来看看怎么调用上面的这些类。

// main.CPP

#include  < iostream >
using   namespace  std;


#include  " a.h "
#include  " b.h "
#include  " c.h "

void  main()
... {
    A a;
    B b;
    C c;

    a.SetColleage(&b, &c);
    b.SetColleage(&a, &c);
    c.SetColleage(&a, &b);

    a.ACallB();
    a.ACallC();

    b.BCallA();
    b.BCallC();

    c.CCallA();
    c.CCallB();
}

好了，从这个调用可以看出来，他们之间的耦合性非常强，这里只是三个对象，而且调用的方式比较统一（因为是例子程序），我们还能把他们的关系给搞清楚，但在现实的软件开发中，往往类间的关系比这里的复杂多了，这个时候我们就要“剪”断这些错乱的关系，而“剪刀”就是Mediator模式。  （未完代续）