Modèle de conception C brève introduction au modèle de chaîne de responsabilité

ChainOfResponsibility : permet à plusieurs objets d'avoir la possibilité de traiter les demandes, évitant ainsi la relation de couplage entre l'expéditeur et le destinataire de la demande. Chaînez cet objet et transmettez la requête le long de la chaîne jusqu'à ce qu'un objet le gère.

Avantages de la chaîne de responsabilité :

Lorsqu'un client soumet une demande, la demande est transmise le long de la chaîne jusqu'à ce qu'un objet ConcreteHandler soit responsable de son traitement.

Pour que ni le destinataire ni l'expéditeur n'aient des informations claires sur l'autre partie et que les objets de la chaîne eux-mêmes ne connaissent pas la structure de la chaîne. Le résultat est que les chaînes de responsabilité simplifient la liaison des objets de sorte qu'ils n'ont besoin de conserver qu'une seule référence à son successeur, plutôt qu'à tous ses destinataires candidats.

Client :

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

Implémentation de la classe :

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

Ce qui précède est le contenu d'une brève introduction au modèle de chaîne de responsabilité du modèle de conception C Pour en savoir plus. contenu associé, veuillez faire attention au site Web PHP chinois (www.php.cn) !