Nehmen wir an, ich habe einige bekannte Werte wie diesen (aberconst char * ist nur ein Beispiel, es könnte komplizierter sein):

const char *A = "A", *B = "B", *C = "C", *D = "D", *E = "E", *F = "F", *G = "G";

Angenommen, ich möchte mich auf eine bestimmte Art und Weise verhalten, wenn das Ergebnis eines Ausdrucks in einer Teilmenge dieser Werte enthalten ist:

if (some_complicated_expression_with_ugly_return_type == A ||
    some_complicated_expression_with_ugly_return_type == C ||
    some_complicated_expression_with_ugly_return_type == E ||
    some_complicated_expression_with_ugly_return_type == G)
{
    ...
}

Ich finde mich dabei, wie ich so etwas oft genug tippe, dass ich mir eine Abkürzung dafür wünsche.

Wenn die Sprache Python wäre, könnte ich leicht sagen:

if some_complicated_expression_with_ugly_return_type in [A, C, E, G]:
    ...

Gibt es eine bekannte, portable Möglichkeit, dies in C ++ 03 ähnlich auszudrücken?

Beachten Sie, dass der Rückgabetyp selbst hässlich ist (fast so hässlich wie der Rückgabetyp vonLambda-Ausdrücke), also möchte ich es auf keinen Fall in einer lokalen Variablen speichern.

Aber der Rückgabetyp tut esnicht müssen mit den Konstanten übereinstimmen - zum Beispiel, wenn der Rückgabetyp warstd::string, es würdenicht implizit konvertierbar zuconst char *, aberoperator == wäre vollkommen in ordnung für den vergleich.

Bisher ist die beste Lösung, die ich habe, Folgendes zu sagen:

const char *items[] = { A, C, E, G };
if (std::find(items, items + sizeof(items) / sizeof(*items),
              some_complicated_expression_with_ugly_return_type)
    != items + sizeof(items) / sizeof(*items))
{
    ...
}

aber es ist verdammt hässlich. Gibt es einen besseren Weg, der auch für Nicht-PODs funktioniert?