Paragonando un po 'a un booleano

Supponi di avere un set di flag, codificato in uint16_t flags. Ad esempio AMAZING_FLAG = 0x02,. Ora ho una funzione. Questa funzione deve verificare se voglio cambiare il flag, perché se voglio farlo, devo scrivere in flash. E questo è costoso. Pertanto, voglio un controllo che mi dica se flags & AMAZING_FLAGè uguale a doSet. Questa è la prima idea:

setAmazingFlag(bool doSet)
{
    if ((flags & AMAZING_FLAG) != (doSet ? AMAZING_FLAG : 0)) {
        // Really expensive thing
        // Update flags
    }
}

Questa non è un'istruzione if intuitiva. Sento che dovrebbe esserci un modo migliore, qualcosa del tipo:

if ((flags & AMAZING_FLAG) != doSet){

}

Ma questo in realtà non funziona, truesembra essere uguale a 0x01.

Quindi, c'è un modo pulito per confrontare un po 'con un booleano?

Per convertire qualsiasi numero diverso da zero in 1 (vero), esiste un vecchio trucco: applicare l' !operatore (non) due volte.

if (!!(flags & AMAZING_FLAG) != doSet){

È necessario convertire la maschera di bit in un'istruzione booleana, che in C è equivalente a valori 0o 1.

• (flags & AMAZING_FLAG) != 0. Il modo più comune.

• !!(flags & AMAZING_FLAG). Un po 'comune, anche OK da usare, ma un po' enigmatico.

• (bool)(flags & AMAZING_FLAG). Moderna via C dalla C99 e oltre.

Prendi una delle alternative sopra, quindi confrontala con il tuo valore booleano usando !=o ==.

Da un punto di vista logico, flags & AMAZING_FLAGè solo una piccola operazione che maschera tutti gli altri flag. Il risultato è un valore numerico.

Per ricevere un valore booleano, è necessario utilizzare un confronto

(flags & AMAZING_FLAG) == AMAZING_FLAG

e ora può confrontare questo valore logico con doSet.

if (((flags & AMAZING_FLAG) == AMAZING_FLAG) != doSet)

In C possono esserci abbreviazioni, a causa delle implicite regole di conversione dei numeri in valori booleani. Quindi potresti anche scrivere

if (!(flags & AMAZING_FLAG) == doSet)

per scrivere più conciso. Ma la versione precedente è migliore in termini di leggibilità.

È possibile creare una maschera in base al doSetvalore:

#define AMAZING_FLAG_IDX 1
#define AMAZING_FLAG (1u << AMAZING_FLAG_IDX)
...

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Ora il tuo assegno può apparire così:

setAmazingFlag(bool doSet)
{
    const uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

    if (flags & set_mask) {
        // Really expensive thing
        // Update flags
    }
}

Su alcune architetture, !!può essere compilato in un ramo e da questo, si possono avere due rami:

1. Normalizzazione di !!(expr)
2. Confrontare con doSet

Il vantaggio della mia proposta è un ramo unico garantito.

Nota: assicurati di non introdurre un comportamento indefinito spostando a sinistra di oltre 30 (supponendo che l'intero sia 32 bit). Questo può essere facilmente raggiunto da astatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Esistono diversi modi per eseguire questo test:

L'operatore ternario potrebbe generare salti costosi:

if ((flags & AMAZING_FLAG) != (doSet ? AMAZING_FLAG : 0))

Puoi anche utilizzare la conversione booleana, che può essere o meno efficiente:

if (!!(flags & AMAZING_FLAG) != doSet)

O la sua alternativa equivalente:

if (((flags & AMAZING_FLAG) != 0) != doSet)

Se la moltiplicazione è economica, puoi evitare i salti con:

if ((flags & AMAZING_FLAG) != doSet * AMAZING_FLAG)

Se flagsè senza segno e il compilatore è molto intelligente, la divisione di seguito potrebbe compilare in un semplice turno:

if ((flags & AMAZING_FLAG) / AMAZING_FLAG != doSet)

Se l'architettura utilizza l'aritmetica del complemento a due, ecco un'altra alternativa:

if ((flags & AMAZING_FLAG) != (-doSet & AMAZING_FLAG))

In alternativa, si potrebbe definire flagsuna struttura con campi di bit e utilizzare una sintassi molto più semplice e leggibile:

if (flags.amazing_flag != doSet)

Purtroppo, questo approccio è solitamente disapprovato perché le specifiche dei bitfield non consentono un controllo preciso sull'implementazione a livello di bit.