Eine kurze Einführung in das Mediatormuster in C++-Entwurfsmustern

Mediatormuster (Mediator): Verwenden Sie ein Mediatorobjekt, um eine Reihe von Objektinteraktionen zu kapseln. Mediatoren machen es überflüssig, dass Objekte explizit aufeinander verweisen, wodurch die Kopplung gelockert wird und es ihnen ermöglicht wird, ihre Interaktionen unabhängig zu ändern.

Vier Rollen:

Abstrakter Vermittler Vermittler

Konkretes Vermittlerobjekt ConcreteMediator

Abstrakte Klasse Abstract

Konkrete abstrakte Klasse ConcreteAbstract

Vorteile des Mediator-Musters:

Das Aufkommen von Mediator reduziert die Kopplung jedes Abstracts, sodass jede Abstract-Klasse und jeder Mediator unabhängig geändert und wiederverwendet werden kann.

Aufgrund der Abstraktion der Art und Weise, wie Objekte zusammenarbeiten, wird die Vermittlung als eigenständiges Konzept behandelt und in einem Objekt gekapselt. Auf diese Weise wird der Fokus der Aufmerksamkeit vom Verhalten der Objekte selbst auf die Interaktion zwischen ihnen verlagert sie, das heißt, das System aus einer objektiveren Perspektive zu betrachten.

Nachteile des Mediator-Modells:

Da ConcreteMediator die Zentralisierung steuert, wird die Komplexität der Interaktion zur Komplexität des Mediators, wodurch der Mediator komplexer wird als alle verantwortlichen ConcreteAbstract-Modelle.

Musterimplementierung:

[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);
    }
};

Kunde:

[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;
}

Das Obige ist der Inhalt des C++-Entwurfsmusters, eine kurze Einführung in das Zwischenmuster. Weitere verwandte Inhalte Bitte achten Sie auf die chinesische PHP-Website (www.php.cn)!