Modèle de conception C brève introduction au modèle médiateur

Modèle médiateur (Mediator) : utilisez un objet médiateur pour encapsuler une série d'interactions d'objets. Les médiateurs éliminent le besoin pour les objets de se référencer explicitement les uns les autres, desserrant ainsi le couplage et leur permettant de modifier indépendamment leurs interactions.

Quatre rôles :

Médiateur abstrait Médiateur

Objet médiateur concret ConcreteMediator

Classe abstraite Abstract

Classe abstraite concrète ConcreteAbstract

Avantages du modèle Mediator :

L'émergence de Mediator réduit le couplage de chaque résumé, permettant à chaque classe abstraite et médiateur d'être modifiés et réutilisés indépendamment.

Puisque nous faisons abstraction de la manière dont les objets collaborent, nous traitons la médiation comme un concept indépendant et l'encapsulons dans un objet. De cette manière, l'attention se déplace du comportement des objets eux-mêmes vers l'interaction entre eux. c'est-à-dire regarder le système d'un point de vue plus objectif.

Inconvénients du modèle du médiateur :

Puisque ConcreteMediator contrôle la centralisation, la complexité de l'interaction devient la complexité du médiateur, ce qui rend le médiateur plus complexe que n'importe quel ConcreteAbstract All responsable.

Implémentation du modèle :

[code]//前向声明
class Abstract;

//中介者抽象类
class Mediator{
public:
    virtual void Send(std::string message, Abstract *abstract){}
};

//抽象类
class Abstract{
protected:
    Mediator *mediator;
public:
    //构造中介者
    Abstract(Mediator *mediator){
        this->mediator = mediator;
    }
};

//具体抽象类1
class ConcreteAbstract1: public Abstract{
public:
    ConcreteAbstract1(Mediator *me):Abstract(me){}
    void Send(std::string message){
        //中介者送出去
        mediator->Send(message, this);
    }
    void Notify(std::string message){
        std::cout << "ConcreteAbstract1 receive message: " << message << "   ---(From ConcreteAbstract2)" << std::endl;
    }
};

//具体抽象类2
class ConcreteAbstract2: public Abstract{
public:
    ConcreteAbstract2(Mediator *me):Abstract(me){}
    void Send(std::string message){
        //中介者送出去
        mediator->Send(message, this);
    }
    void Notify(std::string message){
        std::cout << "ConcreteAbstract2 receive message: "  << message << "   ---(From ConcreteAbstract1)" << std::endl;
    }
};

//具体中介者
class ConcreteMediator: public Mediator{
private:
    //需了解所存的具体抽象类对象
    ConcreteAbstract1 *CA1;
    ConcreteAbstract2 *CA2;
public:
    ConcreteMediator(){}
    void setConcreteMediator(ConcreteAbstract1 *CA1, ConcreteAbstract2 *CA2){
        this->CA1 = CA1;
        this->CA2 = CA2;
    }
    virtual void Send(std::string message, Abstract *abstract){
        if(abstract == CA1)
            CA2->Notify(message);
        else
            CA1->Notify(message);
    }
};

Client :

[code]//Client
int main(){
    ConcreteMediator *m = new ConcreteMediator;

    //具体的抽象这认识具体的中介者
    ConcreteAbstract1 *ca1 = new ConcreteAbstract1(m);
    ConcreteAbstract2 *ca2 = new ConcreteAbstract2(m);
    //让中介者认识两个具体的抽象类
    m->setConcreteMediator(ca1, ca2);

    ca1->Send("Hello");  //Output: ConcreteAbstract2 receive message: Hello   ---(From ConcreteAbstract1)
    ca2->Send("Hi");    //Output: ConcreteAbstract1 receive message: Hi   ---(From ConcreteAbstract2) 

    if(m != NULL){
        delete m;
        m = NULL;
    }
    if(ca1 != NULL){
        delete ca1;
        ca1 = NULL;
    }
    if(ca2 != NULL){
        delete ca2;
        ca2 = NULL;
    }

    return 0;
}

Ce qui précède est le contenu du modèle de conception C, brève introduction au modèle intermédiaire Pour un contenu plus connexe. , veuillez faire attention au site Web PHP chinois (www.php.cn) !