Digamos que tengo un montón de valores conocidos, como este (peroconst char * es solo un ejemplo, podría ser más complicado):

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

Ahora digamos que quiero comportarme de una manera particular si el resultado de alguna expresión está en un subconjunto de esos:

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)
{
    ...
}

Me encuentro escribiendo este tipo de cosas con la frecuencia suficiente como para que quisiera una taquigrafía.

Si el lenguaje fuera Python, fácilmente podría decir:

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

¿Existe una forma portátil y conocida para que exprese esto de manera similar en C ++ 03?

Tenga en cuenta que el tipo de retorno es en sí feo (casi tan feo como el tipo de retorno deexpresiones lambda), entonces ciertamente no quiero almacenarlo en una variable local.

Pero el tipo de retorno haceno tiene que coincidir con la de las constantes, por ejemplo, si el tipo de retorno fuestd::string, seríano ser implícitamente convertible aconst char *, perooperator == Estaría perfectamente bien para la comparación.

Hasta ahora, la mejor solución que tengo es decir algo como:

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))
{
    ...
}

pero es bastante feo ¿Hay una mejor manera, que también funciona para los no POD?