Comparando un poco a un booleano

Digamos que tengo un conjunto de banderas, codificadas en uint16_t flags. Por ejemplo, AMAZING_FLAG = 0x02. Ahora tengo una función. Esta función necesita verificar si quiero cambiar la bandera, porque si quiero hacer eso, necesito escribir en flash. Y eso es caro. Por lo tanto, quiero un cheque que me diga si flags & AMAZING_FLAGes igual a doSet. Esta es la primera idea:

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

Esta no es una declaración if intuitiva. Siento que debería haber una mejor manera, algo como:

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

}

Pero esto en realidad no funciona, trueparece ser igual a 0x01.

Entonces, ¿hay una manera ordenada de comparar un poco con un booleano?

Para convertir cualquier número que no sea cero a 1 (verdadero), hay un viejo truco: aplique el !operador (no) dos veces.

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

Necesita convertir la máscara de bits en una declaración booleana, que en C es equivalente a valores 0o 1.

• (flags & AMAZING_FLAG) != 0. La forma mas comun.

• !!(flags & AMAZING_FLAG). Algo común, también está bien usar, pero un poco críptico.

• (bool)(flags & AMAZING_FLAG). Moderno estilo C desde C99 y más allá solamente.

Tome cualquiera de las alternativas anteriores, luego compárela con su valor booleano usando !=o ==.

Desde un punto de vista lógico, flags & AMAZING_FLAGes solo una operación de bits que enmascara todos los demás indicadores. El resultado es un valor numérico.

Para recibir un valor booleano, usaría una comparación

(flags & AMAZING_FLAG) == AMAZING_FLAG

y ahora puede comparar este valor lógico con doSet.

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

En C puede haber abreviaturas, debido a las reglas de conversión implícitas de números a valores booleanos. Entonces también podrías escribir

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

para escribir eso más conciso. Pero la versión anterior es mejor en términos de legibilidad.

Puede crear una máscara basada en el doSetvalor:

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

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Ahora su cheque puede verse así:

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

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

En algunas arquitecturas, !!puede compilarse en una rama y, de este modo, puede tener dos ramas:

1. Normalización por !!(expr)
2. Comparar con doSet

La ventaja de mi propuesta es una rama única garantizada.

Nota: asegúrese de no introducir un comportamiento indefinido desplazándose a la izquierda más de 30 (suponiendo que el entero sea de 32 bits). Esto se puede lograr fácilmente mediante unstatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Hay varias formas de realizar esta prueba:

El operador ternario podría generar saltos costosos:

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

También puede usar la conversión booleana, que puede o no ser eficiente:

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

O su alternativa equivalente:

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

Si la multiplicación es barata, puede evitar saltos con:

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

Si flagsno está firmado y el compilador es muy inteligente, la siguiente división podría compilarse con un simple cambio:

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

Si la arquitectura usa la aritmética del complemento a dos, aquí hay otra alternativa:

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

Alternativamente, uno podría definir flagscomo una estructura con campos de bits y usar una sintaxis mucho más simple y legible:

if (flags.amazing_flag != doSet)

Por desgracia, este enfoque generalmente está mal visto porque la especificación de los campos de bits no permite un control preciso sobre la implementación a nivel de bits.