Ein bisschen mit einem Booleschen vergleichen

Angenommen, ich habe eine Reihe von Flags, die in einem uint16_t codiert sind flags. Zum Beispiel AMAZING_FLAG = 0x02. Jetzt habe ich eine Funktion. Diese Funktion muss prüfen, ob ich das Flag ändern möchte, denn wenn ich das tun möchte, muss ich in Flash schreiben. Und das ist teuer. Daher möchte ich eine Überprüfung, die mir sagt, ob flags & AMAZING_FLAGgleich ist doSet. Dies ist die erste Idee:

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

Dies ist keine intuitive if-Anweisung. Ich denke, es sollte einen besseren Weg geben, so etwas wie:

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

}

Aber das funktioniert eigentlich nicht, truescheint gleich zu sein 0x01.

Gibt es eine gute Möglichkeit, ein bisschen mit einem Booleschen Wert zu vergleichen?

Um eine Zahl ungleich Null in 1 (wahr) umzuwandeln, gibt es einen alten Trick: Wenden Sie den !Operator (nicht) zweimal an.

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

Sie müssen die Bitmaske in eine boolesche Anweisung konvertieren, die in C den Werten 0oder entspricht 1.

• (flags & AMAZING_FLAG) != 0. Der häufigste Weg.

• !!(flags & AMAZING_FLAG). Etwas üblich, auch in Ordnung, aber etwas kryptisch.

• (bool)(flags & AMAZING_FLAG). Moderner C-Weg ab C99 und darüber hinaus.

Nehmen Sie eine der oben genannten Alternativen und vergleichen Sie sie mit Ihrem Booleschen Wert unter Verwendung von !=oder ==.

Aus logischer Sicht flags & AMAZING_FLAGist nur eine Bitoperation, die alle anderen Flags maskiert. Das Ergebnis ist ein numerischer Wert.

Um einen booleschen Wert zu erhalten, würden Sie einen Vergleich verwenden

(flags & AMAZING_FLAG) == AMAZING_FLAG

und kann nun diesen logischen Wert mit vergleichen doSet.

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

In C kann es aufgrund der impliziten Konvertierungsregeln von Zahlen in boolesche Werte Abkürzungen geben. Du könntest also auch schreiben

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

um das knapper zu schreiben. Die frühere Version ist jedoch in Bezug auf die Lesbarkeit besser.

Sie können eine Maske basierend auf dem doSetWert erstellen :

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

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Jetzt kann Ihr Scheck folgendermaßen aussehen:

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

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

Auf einigen Architekturen !!kann zu einem Zweig kompiliert werden, und auf diese Weise können Sie zwei Zweige haben:

1. Normalisierung durch !!(expr)
2. Vergleichen mit doSet

Der Vorteil meines Vorschlags ist eine garantierte Einzelniederlassung.

Hinweis: Stellen Sie sicher, dass Sie kein undefiniertes Verhalten einführen, indem Sie um mehr als 30 nach links verschieben (vorausgesetzt, die Ganzzahl beträgt 32 Bit). Dies kann leicht erreicht werden durch astatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Es gibt mehrere Möglichkeiten, diesen Test durchzuführen:

Der ternäre Operator kann kostspielige Sprünge erzeugen:

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

Sie können auch die boolesche Konvertierung verwenden, die möglicherweise effizient ist oder nicht:

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

Oder eine gleichwertige Alternative:

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

Wenn die Multiplikation billig ist, können Sie Sprünge vermeiden mit:

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

Wenn flagses nicht signiert ist und der Compiler sehr intelligent ist, kann die folgende Unterteilung zu einer einfachen Verschiebung kompiliert werden:

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

Wenn die Architektur die Zweierkomplementarithmetik verwendet, gibt es hier eine andere Alternative:

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

Alternativ könnte man flagseine Struktur mit Bitfeldern definieren und eine viel einfachere und lesbare Syntax verwenden:

if (flags.amazing_flag != doSet)

Leider wird dieser Ansatz normalerweise verpönt, da die Spezifikation von Bitfeldern keine genaue Kontrolle über die Implementierung auf Bitebene ermöglicht.