Digamos que eu tenha vários valores conhecidos, como esse (masconst char * é apenas um exemplo, poderia ser mais complicado):

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

Agora digamos que eu quero me comportar de uma maneira particular se o resultado de alguma expressão estiver em um subconjunto daqueles:

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

Eu me pego digitando esse tipo de coisa com freqüência suficiente que eu gostaria de uma abreviação para isso.

Se a linguagem fosse Python, eu poderia facilmente dizer:

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

Existe uma maneira bem conhecida e portátil para expressar isso de forma semelhante em C ++ 03?

Note que o tipo de retorno é em si feio (quase tão feio quanto o tipo de retornoexpressões lambda), então eu certamente não quero armazená-lo em uma variável local.

Mas o tipo de retornonão tem que coincidir com as constantes - por exemplo, se o tipo de retorno foistd::string, serianão ser implicitamente conversível paraconst char *, masoperator == estaria perfeitamente bem para a comparação.

Até agora, a melhor solução que tenho é dizer 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))
{
    ...
}

mas é muito feio. Existe uma maneira melhor, que também funciona para não-PODs?