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

ChainOfResponsibility: Ermöglicht mehreren Objekten die Möglichkeit, Anforderungen zu verarbeiten, wodurch die Kopplungsbeziehung zwischen dem Absender und dem Empfänger der Anforderung vermieden wird. Verketten Sie dieses Objekt und leiten Sie die Anforderung entlang der Kette weiter, bis ein Objekt sie verarbeitet.

Vorteile der Verantwortungskette:

Wenn ein Kunde eine Anfrage sendet, wird die Anfrage entlang der Kette weitergeleitet, bis ein ConcreteHandler-Objekt für die Verarbeitung verantwortlich ist.

Damit weder der Empfänger noch der Absender klare Informationen über die andere Partei haben und die Objekte in der Kette selbst die Struktur der Kette nicht kennen. Das Ergebnis ist, dass Verantwortungsketten das Verknüpfen von Objekten vereinfachen, sodass sie nur einen einzigen Verweis auf ihren Nachfolger und nicht auf alle möglichen Empfänger beibehalten müssen.

Kunde:

[code]//Client
int main(){
    Handler *h1 = new ConcreteHandler;
    Handler *h2 = new ConcreteHandler2;
    Handler *h3 = new ConcreteHandler3;

    //设置职责链上家与下家
    h1->setSuccessor(h2);
    h2->setSuccessor(h3);

    //请求
    int request[8] = {2, 5, 14, 22, 18, 3, 23, 20};
    //循环给最小处理者提交请求，不同的数额由不同权限处理者处理
    for(auto i = 0; i < 8; ++i){
        h1->HandleRequest(request[i]);
    }
    // Output:
    //     Handler request
    //     Handler request
    //     Handler2 request
    //     Handler3 request
    //     Handler2 request
    //     Handler request
    //     Handler3 request
    //     Handler3 request

    return 0;
}

Klassenimplementierung:

[code]//Handler处理类
class Handler{
protected:
    Handler *successor;
public:
    //设置继任者
    void setSuccessor(Handler *successor){
        this->successor = successor;
    }
    //处理请求的抽象方法
    virtual void HandleRequest(int request){}
};

//具体处理类，处理它们负责的请求，可访问的后继者，如果可以处理该请求，就处理之，否则就将该请求转发给它的后继者
class ConcreteHandler: public Handler{
public:
    virtual void HandleRequest(int request)override{
        //0~10在此处理
        if(request >= 0 && request < 10){
            std::cout << "Handler request\n";
        }else if(successor != NULL) //否则转移到下一位
            successor->HandleRequest(request);
    }
};

class ConcreteHandler2: public Handler{
public:
    virtual void HandleRequest(int request)override{
        //10~20在此处理
        if(request >= 10 && request < 20){
            std::cout << "Handler2 request\n";
        }else if(successor != NULL) //否则转移到下一位
            successor->HandleRequest(request);
    }
};

class ConcreteHandler3: public Handler{
public:
    virtual void HandleRequest(int request)override{
        //20~30在此处理
        if(request >= 20 && request < 30){
            std::cout << "Handler3 request\n";
        }else if(successor != NULL) //否则转移到下一位
            successor->HandleRequest(request);
    }
};

Das Obige ist der Inhalt eines kurzen Verständnisses des Chain-of-Responsibility-Modells in C++-Entwurfsmustern Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!