mode de commande Charpter23

Mode de commande Présentation

mode de commande (la commande), Encapsulate une demande d'un objet, rendant ainsi vos clientsutilisant différents paramétrage de la demande, la fileattente de demande oudemandesjournal etsouteniropérations annulables.

mode de commande avantages: 1) il peut plus facilement concevoir une fileattente de commande; 2) nécessaire pour déposer le cas, la commande peut être relativement facilement connecté; 3) permet un de décider si la demande reçue est une demande de droitveto. 4) peut être facilement réalisée et redo demande de révocation; 5) Étant donnéles commandes spécifiques pour ajouternouvelles classes n'affectent pasautres classes, doncajoutnouvelles commandes spécifiques de classe facilement. 6) une requête de mode de commande à l'objet et l'objet sait comment effectuer une opération séparée.

principes de développement Agile nous dit de ne pas ajouter de deviner en fonction de la fonction réelle du code n'est pas nécessaire. Si vous ne savez pas si vous avez besoin d'une commande système, généralement ne pas se précipiter pour mettre en œuvre, en fait, au besoin par ce mode est pas difficile à réaliser la reconstruction, où ils sont vraiment nécessaires, telles que les opérations Undo / redo et d'autres fonctions, l'original code mode de commande refactoring est logique.

Mode de commande des diagrammes de classes UML

 

diagramme de classes UML plus facile à comprendre une implémentation particulière

 

  

le code C pour obtenir de

 Le code est conçu pour faciliter la compréhension de ce mode n'est pas programmé selon le diagramme de classes UML

// Récepteur类
#ifndef _RECEIVER_HPP
 #define _RECEIVER_HPP 

#include <iostream> en utilisant l' espace de noms std; classe récepteur {
 publique :
     vide action1 () { 
        Cout << " action1 " << endl; 
    } Vide action2 () { 
        Cout << " action2 " << endl; 
    } 
}; #fin si

 


    

// Commande类
#ifndef _COMMAND_HPP
 #define _COMMAND_HPP 
#include " receiver.hpp " 

class Commande {
 publique :
     virtuelle  vide excute () = 0 ; 
protégé : 
    Récepteur * récepteur; 

}; 

#fin si

// ConcreteCommand1类
#ifndef _CONCRETECOMMAND1_HPP
 #define _CONCRETECOMMAND1_HPP 

#include " command.hpp " 

class ConcreteCommand1: publique Commande {
 publique : 
    ConcreteCommand1 (récepteur * rec) { 
        récepteur = rec; 
    } 

    Virtuel  vide excute () override { 
         récepteur -> action1 (); 
     } 

}; 

#fin si

// ConcreteCommand2类
#ifndef _CONCRETECOMMAND2_HPP
 #define _CONCRETECOMMAND2_HPP 

#include " command.hpp " 

class ConcreteCommand2: publique Commande {
 publique : 
    ConcreteCommand2 (récepteur * rec) { 
        récepteur = rec; 
    }; 
    virtuelle  vide excute () override { 
        récepteur -> action2 (); 
    } 

}; 

#fin si

// Invocateur类
#ifndef _INVOKER_HPP
 #define _INVOKER_HPP 

#include <Liste> 
#include " command.hpp " en 
utilisant l'  espace de noms std;
classe de commandement;
classe Invocateur {
 publics :
     vide addCmd (commande * cmd) { 
        listCmd.push_back (cmd); 
    } 
    Vide delcmd (commande * cmd) { 
        listCmd.remove_if ([ =] (Commande * tmp) { retour tmp == cmd;}); 
    } 
    Vide notify () {
         pour (auto i: listCmd) {
            i-> excute (); 
        } 
    } 
Privé : 
    Liste <Commande *> listCmd; 
}; 

#fin si

// 客户端程序 
#include <iostream> 
#include " concretecommand1.hpp " 
#include " concretecommand2.hpp " 
#include " receiver.hpp " 
#include " invoker.hpp " en 

utilisant l'  espace de noms std;
int main () { 
    récepteur * = récepteur nouveau récepteur (); 
    ConcreteCommand1 * cmd1 = nouveau ConcreteCommand1 (récepteur); 
    ConcreteCommand2 * cmd2 = nouveau ConcreteCommand2 (récepteur); 
    Invocateur * invocateur =nouveau Invoker (); 
    invoker -> addCmd (cmd1); 
    invoker -> addCmd (cmd1); 
    invoker -> addCmd (cmd2); 
    invoker -> notify (); 
    Cout << " --------------- " << endl; 
    invoker -> delcmd (cmd1); 
    invoker -> notify (); 
    getchar (); 
    retourner  0 ; 
}