Comparer un peu à un booléen

Disons que j'ai un ensemble de drapeaux, encodés dans un uint16_t flags. Par exemple AMAZING_FLAG = 0x02,. Maintenant, j'ai une fonction. Cette fonction doit vérifier si je veux changer le drapeau, car si je veux le faire, je dois écrire en flash. Et c'est cher. Par conséquent, je veux un chèque qui me dit si flags & AMAZING_FLAGest égal à doSet. Ceci est la première idée:

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

Ce n'est pas une instruction if intuitive. Je pense qu'il devrait y avoir un meilleur moyen, quelque chose comme:

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

}

Mais cela ne fonctionne pas réellement, truesemble être égal à 0x01.

Alors, y a-t-il un bon moyen de comparer un peu à un booléen?

Pour convertir un nombre non nul en 1 (vrai), il existe une vieille astuce: appliquer l' !opérateur (pas) deux fois.

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

Vous devez convertir le masque de bits en une instruction booléenne, qui en C équivaut à des valeurs 0ou 1.

• (flags & AMAZING_FLAG) != 0. La manière la plus courante.

• !!(flags & AMAZING_FLAG). Un peu commun, également OK à utiliser, mais un peu cryptique.

• (bool)(flags & AMAZING_FLAG). Chemin C moderne à partir de C99 et au-delà uniquement.

Prenez l'une des alternatives ci-dessus, puis comparez-la avec votre booléen en utilisant !=ou ==.

D'un point de vue logique, ce flags & AMAZING_FLAGn'est qu'une opération de bits masquant tous les autres drapeaux. Le résultat est une valeur numérique.

Pour recevoir une valeur booléenne, vous utiliseriez une comparaison

(flags & AMAZING_FLAG) == AMAZING_FLAG

et peut maintenant comparer cette valeur logique à doSet.

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

En C, il peut y avoir des abréviations, en raison des règles de conversion implicites des nombres en valeurs booléennes. Vous pouvez donc aussi écrire

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

d'écrire que plus laconique. Mais l'ancienne version est meilleure en termes de lisibilité.

Vous pouvez créer un masque basé sur la doSetvaleur:

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

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Maintenant, votre chèque peut ressembler à ceci:

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

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

Sur certaines architectures, !!peut être compilé en une branche et par cela, vous pouvez avoir deux branches:

1. Normalisation par !!(expr)
2. Comparer aux doSet

L'avantage de ma proposition est une seule succursale garantie.

Remarque: assurez-vous de ne pas introduire de comportement indéfini en décalant vers la gauche de plus de 30 (en supposant que l'entier est de 32 bits). Ceci peut être facilement réalisé par unstatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Il existe plusieurs façons d'effectuer ce test:

L'opérateur ternaire peut générer des sauts coûteux:

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

Vous pouvez également utiliser la conversion booléenne, qui peut être efficace ou non:

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

Ou son alternative équivalente:

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

Si la multiplication est bon marché, vous pouvez éviter les sauts avec:

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

Si flagsn'est pas signé et que le compilateur est très intelligent, la division ci-dessous peut se compiler en un simple décalage:

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

Si l'architecture utilise l'arithmétique du complément à deux, voici une autre alternative:

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

Alternativement, on pourrait définir flagscomme une structure avec des champs de bits et utiliser une syntaxe beaucoup plus simple et lisible:

if (flags.amazing_flag != doSet)

Hélas, cette approche est généralement mal vue car la spécification des champs de bits ne permet pas un contrôle précis de l'implémentation au niveau des bits.