Gibt es irgendwelche design-Muster zu vermeiden, die eine verschachtelte switch case?

Wenn die Leistung nicht, dass das ein großes Problem, dann eine Karte von Funktionszeigern, könnte das eine Lösung.

Vorausgesetzt, das label A, B , C ... sind kleine integral-Werte von weniger als 255.

• Setup die Karte zuerst

  #define KEY(a,b)  ( (a<<8) | b )
  
  std::map<int, function_pointer_type>  dispatcher =
  {
      { KEY(A,B), ab_handler},
      { KEY(A,C), ac_handler},
      { KEY(B,C), bc_handler},
      //etc
  };

• Verwenden Sie die Karte aufrufen, entsprechende Prozedur für jeden Satz von Eingabe:

   dispatcher[KEY(input1,input2)] (/* args */);

Beachten Sie, dass Sie haben, um den setup-dispatcher mit jedem möglichen paar von Eingängen. Auch, wenn das paar KEY(A,B) und KEY(B,A) sind gleiche Fall ist, dann können Sie eine Funktion schreiben, die aufgerufen invoke in diesem Fall behandeln, um einen einheitlichen Sprachgebrauch für den rest des Codes.

 void invoke(int input1, int input2, /* args */)
 {
     if (dispatcher.find(KEY(input1, input2)) != dispatcher.end() )
           dispatcher[KEY(input1,input2)] (/* args */);
     else
           dispatcher[KEY(input2,input1)] (/* args */);
 }

dann verwenden Sie es als:

 invoke(input1, input2, /* args */);
 invoke(input2, input1, /* args */);  //still okay!

Hoffe, das hilft.

Eine Möglichkeit ist das aufsplitten der code in einer Funktion pro verschachtelte Fall, also dein Beispiel würde haben 6 Funktionen:

void process_A_A() { ... }
void process_A_B() { ... }
void process_B_A() { ... }
void process_B_B() { ... }
void process_C_A() { ... }
void process_C_B() { ... }

Dann, setzen Sie Sie in ein array Initialisierung für sehr schnelle (Konstante Zeit-lookup zur Laufzeit:

typedef std::function<void(void)> Function;  //or: void (*)(void)
Function f[Input1Count][Input2Count];
f[A][A] = &process_A_A;
f[A][B] = &process_A_B;
...

Zum aufrufen der entsprechenden Funktion schreiben:

f[input1][input2]();

Beachten Sie, dass durch die Verwendung der C++11 std::function Typ, die Funktionen, die nicht zu den klassischen Funktionszeigern; Sie kann auch lambda-Funktionen oder Funktor-Objekte.

Sie können auch halten einige Teile leer oder weisen Sie die gleiche Funktion mehrere Male. Wenn Sie sich entscheiden, halten einige Einträge leer (also es sollte nicht alles, was man in so einem Fall), überprüfen Sie die Funktion Objekt vor dem Aufruf:

if (f[input1][input2])
    f[input1][input2]();

Den vorgeschlagenen Antworten mit Karte oder Tabelle von Zeigern zu handhaben Funktionen sind ok. Ich sehe aber zwei Nachteile:
1) Ein kleiner Leistungsabfall im Vergleich zu den manuellen verschachtelten switches.
2) Fall-handling-Methoden nicht vollständig selbst-beschreibend. Ich meine, Sie haben zu erwähnen, jeder Griff Methoden zweimal in seiner definition und in dem Ort, wo Sie init der Karte.

Sehe ich zwei alternativen:
1) Source-code-Generierung. Automatisch generiert verschachtelte switches von einigen Art der Darstellung. Naja... es ist eine sehr gute option zum erstellen eines optimalen code, wenn nichts ausmacht das hinzufügen von code-Generierung für eine so kleine Aufgabe.
2) Mit Präprozessor-hacks. Nicht das eleganteste, aber durchaus Interesse Weg, damit es funktioniert.

Zuerst erklären wir X-Makro für unsere enum:

#define ELEMENTS(processor) \
processor(firstElement)     \
processor(secondElement)    \
processor(thirdElement)

Können wir es verwenden, zu erklären, das enum selbst:

#define ENUM_PROCESSOR(arg) arg,

enum class
{
    ELEMENTS(ENUM_PROCESSOR)
};

#undef ENUM_PROCESSOR
Now we can add method that uses macros to generate nested switches:

void processElements(const Elements element1,
                     const Elements element2)
{
    //These macros are useful to trick the preprocessor to allow recursive macro calls
    //https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms
    #define EMPTY(...)
    #define DEFER(...) __VA_ARGS__ EMPTY()
    #define EXPAND(...) __VA_ARGS__
    #define ELEMENTS_INT() ELEMENTS

    #define PROCESS_NESTED_ENUM_VALUE(value)                                         \
    case Elements::value:                                                            \
    {                                                                                \
        process<Value1, Elements::value>();                                          \
        break;                                                                       \
    }

    #define PROCESS_ENUM_VALUE(value)                                                \
    case Elements::value:                                                            \
    {                                                                                \
        constexpr Elements Value1 = Elements::value;                                 \
        switch (element2)                                                            \
        {                                                                            \
            DEFER(ELEMENTS_INT)()(PROCESS_NESTED_ENUM_VALUE)                         \
        };                                                                           \
                                                                                     \
        break;                                                                       \
    }

    switch (element1)
    {
        EXPAND(ELEMENTS(PROCESS_ENUM_VALUE));
    };

    #undef EMPTY
    #undef DEFER
    #undef EXPAND

    #undef ELEMENT_TYPES_INT
    #undef PROCESS_ENUM_VALUE
    #undef PROCESS_NESTED_ENUM_VALUE
}

Viele Anstrengungen gemacht werden, um "trick", den Präprozessor zu erweitern ELEMENTE rekursiv. Die Grundidee ist gut beschrieben hier.

Nun deklarieren wir unser Handler als template-Funktion Spezialisierung:

template <Elements Element1, Elements Element2>
void process();

template<>
void process<Elements::firstElement, Elements::firstElement>()
{
    //some code 1;
}

...