[C] Utilizzo degli enum come shift di 1. Quando si usa?

[-Ivan-]

Ho bisogno di un chiarimento su un uso degli enumeratori che mi è capitato di incontrare un paio di volte ma non mi è chiaro.

enum EContext
{
     ESingleplayer,
     EMultiplayer,
     EOutpost,
     ....
}

L'enumerator viene utilizzato all'interno di una funzione in questo modo:

void SomeClass::Update(int32 context)
{
     if ( context & (1<<(int32)m_currentContext) )
     {
          ... do stuff
     }
}

m_currentContext è un membro di SomeClass di tipo EContext.
Il parametro context della funzione è passato come shift di 1 quando la funzione viene chiamata (questo uso è piuttosto scomodo, una alternativa migliore è che il valore corretto sia assegnato direttamente nella dichiarazione dell'enum così da non dover eseguire lo shift ogni volta che si chiama la funzione ma il concetto comunuqe è lo stesso):

Update(1<<(int32)EOutpost);

Spero di ricordare bene perchè non ho il codice sotto mano.
Mi sapete dire in quali casi ed a quale scopo sia utile utilizzare questo tipo di soluzione?

[-Ivan-]

Originariamente inviato da Antonio23

quando il tuo int32 rappresenta una maschera di bit in cui ogni posizione identifica una funzionalità...

...personalmente questa notazione non mi piace, preferisco l'utilizzo dei bitfield che sono nati allo scopo:

http://msdn.microsoft.com/en-us/library/ewwyfdbe.aspx

Ma quello che non capisco è quale sia la convenienza nell'usare un enum in quel modo piuttosto che semplicemente utilizzare un if (tipo == Enum::valore).
E' semplicemente perchè, in caso di un enum con molti valori, si dovrebbero utilizzare troppi && concatenati per testare tutti i valori validi?

[WarDuck]

Originariamente inviato da -Ivan-

Ma quello che non capisco è quale sia la convenienza nell'usare un enum in quel modo piuttosto che semplicemente utilizzare un if (tipo == Enum::valore).
E' semplicemente perchè, in caso di un enum con molti valori, si dovrebbero utilizzare troppi && concatenati per testare tutti i valori validi?

No lì sta testando se il contesto che tu passi (come int) ha un bit acceso in posizione m_current_context.

Brutto, illegibile e scomodo.

Comunque su GCC è perfettamente legale fare questo:

enum Colors
{
    RED = 0x1,      /* bits 001 */
    YELLOW = 0x2,   /* bits 010 */
    GREEN = 0x4     /* bits 100 */
};

/* Nota: i bit non si sovrappongono */

int main(void)
{
    enum Colors color = (RED|YELLOW); /* bits 011 */

    int has_yellow = !!(color & YELLOW);

    printf("Color has YELLOW? %d\n", has_yellow); /* stampa 1 */
    return 0;
}

A questo punto potresti fare cose simpatiche di questo tipo:

enum Colors
{
    RED = 0x1,      /* bits 001 */
    YELLOW = 0x2,   /* bits 010 */
    ORANGE = 0x3,   /* bits 011 */
    GREEN = 0x4     /* bits 100 */
};

Dove ORANGE è l'unione in bits delle due componenti RED e YELLOW .