C++25设计模式之中介模式

图片引用于百度

简介：是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。

优点：降低了类的复杂度，将一对多转化成了一对一

缺点：中介者会庞大，变得复杂难以维护

例子背景：现有某人想买某物，通过中介去买

中介模式代码：

• 抽象people类：

#pragma once
#include <string>
#include <iostream>
using namespace std;

class Mediator;

class Person
{
public:
        Person() {}
        virtual ~Person() {}
public:
        virtual void SetMediator(Mediator* mediator) = 0;
        virtual void SendMessage(std::string msg) = 0;
        virtual void GetMessage(std::string msg) = 0;
};

• 具体people类：

#pragma once
#include "Person.h"

class Store : public Person
{
public:
        Store();
        ~Store();
private:
        Mediator* m_mediator = nullptr;
public:
        virtual void SetMediator(Mediator* mediator);
        virtual void SendMessage(std::string msg);
        virtual void GetMessage(std::string msg);
};

class Customer : public Person
{
public:
        Customer();
        ~Customer();
private:
        Mediator* m_mediator = nullptr;
public:
        virtual void SetMediator(Mediator* mediator);
        virtual void SendMessage(std::string msg);
        virtual void GetMessage(std::string msg);
};

• 具体people类cpp：

#include "People.h"
#include "Mediator.h"

Store::Store()
{

}

Store::~Store()
{

}

void Store::SetMediator(Mediator* mediator)
{
        m_mediator = mediator;
}

void Store::SendMessage(std::string msg)
{
        m_mediator->SendMsg(msg, this);
}

void Store::GetMessage(std::string msg)
{
        cout << "商店收到消息：" << msg << endl;
}

Customer::Customer()
{

}

Customer::~Customer()
{

}

void Customer::SetMediator(Mediator* mediator)
{
        m_mediator = mediator;
}

void Customer::SendMessage(std::string msg)
{
        m_mediator->SendMsg(msg, this);
}

void Customer::GetMessage(std::string msg)
{
        cout << "顾客收到消息：" << msg << endl;
}

• 抽象中介类：

#pragma once
#include "Person.h"

class Mediator
{
public:
        Mediator() {}
        virtual ~Mediator() {}
public:
        virtual void SendMsgToStore(Person* store) = 0;
        virtual void SendMsgToCustomer(Person* people) = 0;
        virtual void SendMsg(string msg, Person* receiver) = 0;
};

• 具体中介类：

#pragma once
#include "Mediator.h"

class HuaqiangbeiMediator : public Mediator
{
public:
        HuaqiangbeiMediator() {}
private:
        Person* m_store = nullptr;
        Person* m_people = nullptr;
public:
        virtual void SendMsgToStore(Person* store) { m_store = store; }
        virtual void SendMsgToCustomer(Person* people) { m_people = people; }
        virtual void SendMsg(string msg, Person* receiver)
        {
                if( m_store != receiver )
                        m_store->GetMessage(msg);
                else 
                        m_people->GetMessage(msg);
        }
};

• 引用：

#include "HuaqiangbeiMediator.h"
#include "People.h"

int main()
{
        shared_ptr<HuaqiangbeiMediator> hqb(new HuaqiangbeiMediator);
        shared_ptr<Store> store(new Store);
        shared_ptr<Customer> customer(new Customer);

        hqb->SendMsgToCustomer(customer.get());
        hqb->SendMsgToStore(store.get());
        store->SetMediator(hqb.get());
        customer->SetMediator(hqb.get());

        customer->SendMessage("我想买个平板电脑");
        store->SendMessage("平板电脑3000块");

        getchar();
        return 0;
}

总结：
中介模式(Mediator)：中介模式封装了系统中对象间的交互方式，解耦购买者和商店。如果一个系统中对象之间的联系呈现出网状结构，对象之间存在大量多对多关系，将导致关系及其复杂，这时候使用中介类将同事对象之间的关系行为进行分离和封装，使之成为一个松耦合的系统

作者：丶梦爱
博客：https://blog.youkuaiyun.com/u014732297（转载请说明出处）