Comparando um pouco com um booleano

Digamos que eu tenha um conjunto de sinalizadores, codificado em uint16_t flags. Por exemplo AMAZING_FLAG = 0x02,. Agora, eu tenho uma função. Essa função precisa verificar se eu quero alterar o sinalizador, porque se eu quiser fazer isso, preciso escrever para piscar. E isso é caro. Portanto, quero uma verificação que me diga se flags & AMAZING_FLAGé igual a doSet. Esta é a primeira ideia:

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

Esta não é uma declaração intuitiva. Eu sinto que deveria haver uma maneira melhor, algo como:

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

}

Mas isso realmente não funciona, trueparece ser igual a 0x01.

Então, existe uma maneira legal de comparar um pouco com um booleano?

Para converter qualquer número diferente de zero em 1 (verdadeiro), existe um truque antigo: aplique o !operador (não) duas vezes.

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

Você precisa converter a máscara de bits em uma instrução booleana, que em C é equivalente a valores 0ou 1.

• (flags & AMAZING_FLAG) != 0. A maneira mais comum.

• !!(flags & AMAZING_FLAG). Um pouco comum, também é bom de usar, mas um pouco enigmático.

• (bool)(flags & AMAZING_FLAG). C moderno a partir de C99 e somente além.

Pegue uma das alternativas acima e compare-a com o seu booleano usando !=or ==.

Do ponto de vista lógico, flags & AMAZING_FLAG é apenas uma operação pouco mascarando todos os outros sinalizadores. O resultado é um valor numérico.

Para receber um valor booleano, você usaria uma comparação

(flags & AMAZING_FLAG) == AMAZING_FLAG

e agora pode comparar esse valor lógico com doSet.

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

Em C, pode haver abreviações, devido às regras implícitas de conversão de números em valores booleanos. Então você também pode escrever

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

para escrever isso mais conciso. Mas a versão anterior é melhor em termos de legibilidade.

Você pode criar uma máscara com base no doSetvalor:

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

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Agora seu cheque pode ficar assim:

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

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

Em algumas arquiteturas, !!pode ser compilado em uma ramificação e, com isso, você pode ter duas ramificações:

1. Normalização por !!(expr)
2. Comparado a doSet

A vantagem da minha proposta é uma filial única garantida.

Nota: certifique-se de não introduzir um comportamento indefinido, deslocando a esquerda em mais de 30 (assumindo que o número inteiro seja 32 bits). Isso pode ser facilmente alcançado por umstatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Existem várias maneiras de executar este teste:

O operador ternário pode gerar saltos caros:

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

Você também pode usar a conversão booleana, que pode ou não ser eficiente:

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

Ou sua alternativa equivalente:

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

Se a multiplicação for barata, você pode evitar saltos com:

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

Se flagsnão estiver assinado e o compilador for muito inteligente, a divisão abaixo poderá ser compilada para uma mudança simples:

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

Se a arquitetura usa a aritmética de complemento de dois, aqui está outra alternativa:

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

Como alternativa, pode-se definir flagscomo uma estrutura com campos de bits e usar uma sintaxe muito mais simples e legível:

if (flags.amazing_flag != doSet)

Infelizmente, essa abordagem geralmente é desaprovada, porque a especificação de campos de bits não permite controle preciso sobre a implementação no nível de bits.