c++中介者模式

中介者模式：有很多相互依赖的类，将他们的依赖关系集中到中介者中。中介者抽象的是它们之间的依赖关系，这种依赖关系并不会消失，只是集中到了中介者身上。比如：很多同事一起办公，但是工作需要，经常要相互沟通，而我们直接找到对方代价很大，而通过发送微信转达对方是很快的，微信就扮演者中介者。中介者和外观模式，两者相同在于都是很多类相互协作，然而前者强调内部之间的沟通，后者强掉它们与外部沟通。

#include <iostream>
using namespace std;

//没有用中介者模式
namespace unMediator {

    class ColleagueA;
    class ColleagueB;
    class ColleagueC;

    class ColleagueA {
    public:
        void foob(ColleagueB *b) { cout << "a 调用 b" << endl; }
        void fooc(ColleagueC *c) { cout << "a 调用 c" << endl; }
    };

    class ColleagueB {
    public:
        void fooa(ColleagueA *a) { cout << "b 调用 a" << endl; }
        void fooc(ColleagueC *c) { cout << "b 调用 c" << endl; }
    };

    class ColleagueC {
    public:
        void fooa(ColleagueA *a) { cout << "c 调用 a" << endl; }
        void foob(ColleagueB *b) { cout << "c 调用 b" << endl; }
    };

}

//使用中介者模式
namespace Mediator {

    class Colleague {
    public:
        virtual ~Colleague() = default;
    };

    class Mediator {
    public:
        Mediator(Colleague *src, Colleague *dst) : src(src), dst(dst) {}

        virtual void foo() = 0;

        virtual ~Mediator() = default;

    protected:
        Colleague *src;
        Colleague *dst;
    };

    class ColleagueA : public Colleague {
    public:
        void foo(Mediator &m) {
            m.foo();
        }
    };

    class ColleagueB : public Colleague {
    public:
        void foo(Mediator &m) {
            m.foo();
        }
    };

    class ColleagueC : public Colleague {
    public:
        void foo(Mediator &m) {
            m.foo();
        }
    };

    class MediatorAB : public Mediator {
    public:
        MediatorAB(Colleague *src, Colleague *dst) : Mediator(src, dst) {}

        void foo() override {
            cout << "a 调用 b" << endl;
        }
    };

    class MediatorAC : public Mediator {
    public:
        MediatorAC(Colleague *src, Colleague *dst) : Mediator(src, dst) {}

        void foo() override {
            cout << "a 调用 c" << endl;
        }
    };

    class MediatorBA : public Mediator {
    public:
        MediatorBA(Colleague *src, Colleague *dst) : Mediator(src, dst) {}

        void foo() override {
            cout << "b 调用 a" << endl;
        }
    };

    class MediatorBC : public Mediator {
    public:
        MediatorBC(Colleague *src, Colleague *dst) : Mediator(src, dst) {}

        void foo() override {
            cout << "b 调用 c" << endl;
        }
    };

    class MediatorCA : public Mediator {
    public:
        MediatorCA(Colleague *src, Colleague *dst) : Mediator(src, dst) {}

        void foo() override {
            cout << "c 调用 a" << endl;
        }
    };

    class MediatorCB : public Mediator {
    public:
        MediatorCB(Colleague *src, Colleague *dst) : Mediator(src, dst) {}

        void foo() override {
            cout << "c 调用 b" << endl;
        }
    };

}

int main()
{
    //非中介者模式
    unMediator::ColleagueA ua;
    unMediator::ColleagueB ub;
    unMediator::ColleagueC uc;

    ua.foob(&ub);
    ua.fooc(&uc);
    ub.fooa(&ua);

    //中介者模式
    Mediator::ColleagueA a;
    Mediator::ColleagueB b;
    Mediator::ColleagueB c;

    Mediator::MediatorAB atob (&a, &b);
    Mediator::MediatorAC atoc (&a, &c);
    Mediator::MediatorBA btoa (&b, &a);

    a.foo(atob);
    a.foo(atoc);
    b.foo(btoa);

    return 0;
}

中介者模式稳定部分是它们之间的相互依赖关系Mediator和协作关系Colleague，易变的部分是同事类可能进一步增加，关系也会进一步增加。