c idées sur la réduction de cette fonction?

Question

J'ai ce cas de commutateur énorme avec des déclarations de cas de commutateur imbriqués dans ce que je me demandais si quelqu'un avait des idées sur la façon de nettoyer?

switch (datatype) { 
    case STR: 
    { 
     switch(operation) 
     { 
       case EQUALS: 
       { 
        /* perform str compare */ 
       } 
       case NOTEQUALS: 
       { 
       } 
       case LT: 
       { 
       } 
       case GT: 
       { 
       } 
       case GTE: 
       { 
       } 
       case LTE: 
       { 
       } 
       default: 
       break; 
     } 
     break; 
    } 
    case VER: 
    { 
     switch(operation) 
     { 
       case EQUALS: 
       { 
        /* perform version compare */ 
       } 
       case NOTEQUALS: 
       { 
       } 
       case LT: 
       { 
       } 
       case GT: 
       { 
       } 
       case GTE: 
       { 
       } 
       case LTE: 
       { 
       } 
       default: 
       break; 
     } 
     break; 
    } 
    case INT: 
    { 
     /* same */ 
    } 
    case FLOAT: 
    { 
     /* same */ 
    } 
    /* ... more types ... */ 
    /* ... .......... ... */ 
    default: 
     break; 
} 

Answer 1

Si les valeurs de l'opération sont contiguës, vous pouvez créer une table de pointeurs de fonction. En fait, vous pouvez créer une table 2D de pointeurs de fonction avec une fonction séparée pour gérer chaque combinaison opération/type. par exemple

// do some range checking on input params 
// invoke the handler 
handlers[datatype][operation](); 

Answer 2

Vous pouvez essayer the command pattern.

Answer 3

Vous pouvez utiliser un grand nombre de pointeurs de fonction, puis appeler la fonction appropriée en fonction de l'indexation du pointeur de fonction correct dans le tableau.

Answer 4

Créez des tables (tableaux) avec des pointeurs sur les fonctions qui s'y trouvent. Vous pouvez ensuite rechercher func[STR][EQUALS] pour effectuer l'appel approprié. L'appel finirait par ressembler à ça ...

Func[datatype][operation](); 

Answer 5

Le cas NOTEQUALS peut toujours être écrit en termes de EQUALS cas; de manière similaire, GTE en termes de LT et LTE en termes de GE. Donc, faites le commutateur externe en termes de operation, et seulement trois de ces six cas devront activer le datatype.

Answer 6

avez-vous envisagé de manière créative d'utiliser une série de pointeurs de fonction et de les stocker dans une structure?

-le correctement et vous pouvez imiter des objets et faire quelque chose comme cela:

bool someArbitraryFunction (dataType aDatatype, operations anOperation) 
{ 
someUnknownStruct.datatype = aDatatype; 
someUnknownStruct.operation = anOperation; 
return someUnknownStruct->doMath(1,2); 
} 

et vous pouvez mettre toutes les fonctions mathématiques nécessaires, énumérations et struct dans un fichier d'en-tête quelque part. Nettoie la "viande" du code, et rend le calcul portable (il suffit de l'importer où vous en avez besoin).

Answer 7

En supposant que votre cas peut tout retour d'une simple valeur booléenne, les six cas logiques peuvent être réécrites en termes de LT et equals, comme suit:

switch(operation) { 
    case EQUALS: 
    return isEquals(); 
    case NOTEQUALS: 
    return !isEquals(); 
    case LT: 
    return isLT(); 
    case GT: 
    return !isLT() && !isEquals(); 
    case GTE: 
    return !isLT(); 
    case LTE: 
    reutrn isLT() || isEquals(); 
    default: 
    break; 
} 

Cela ne ferait que vous avez besoin d'écrire la logique pour ISLT() et isEquals(), qui ferait le type de données de commutation si nécessaire. Cela élimine une quantité importante de duplication de code inutile, mais ne sacrifie pas beaucoup de lisibilité.

Ceci peut être combiné avec des pointeurs de fonction comme Stephen Doyle et rikh ont déjà suggéré, ce qui éliminerait complètement l'instruction switch().