Porównywanie trochę do wartości logicznej

Powiedzmy, że mam zestaw flag zakodowanych w uint16_t flags. Na przykład AMAZING_FLAG = 0x02. Teraz mam funkcję. Ta funkcja musi sprawdzić, czy chcę zmienić flagę, ponieważ jeśli chcę to zrobić, muszę napisać, aby flashować. A to jest drogie. Dlatego chcę testu, który mówi mi, czy flags & AMAZING_FLAGjest równy doSet. To jest pierwszy pomysł:

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

Nie jest to intuicyjna instrukcja if. Wydaje mi się, że powinien istnieć lepszy sposób, na przykład:

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

}

Ale to tak naprawdę nie działa, truewydaje się być równe 0x01.

Czy istnieje dobry sposób na porównanie z wartością logiczną?

Aby przekonwertować dowolną niezerową liczbę na 1 (prawda), istnieje stara sztuczka: zastosuj !(nie) operator dwa razy.

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

Musisz przekonwertować maskę bitową na instrukcję boolean, która w C jest równoważna wartościom 0lub 1.

• (flags & AMAZING_FLAG) != 0. Najczęstszy sposób.

• !!(flags & AMAZING_FLAG). Nieco powszechne, również OK, aby użyć, ale nieco tajemnicze.

• (bool)(flags & AMAZING_FLAG). Nowoczesny sposób C tylko z C99 i nie tylko.

Wybierz dowolną z powyższych opcji, a następnie porównaj ją z wartością logiczną za pomocą !=lub ==.

Z logicznego punktu widzenia flags & AMAZING_FLAGjest to tylko niewielka operacja maskująca wszystkie inne flagi. Wynik jest wartością liczbową.

Aby otrzymać wartość logiczną, użyłbyś porównania

(flags & AMAZING_FLAG) == AMAZING_FLAG

i może teraz porównać tę wartość logiczną z doSet.

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

W C mogą występować skróty z powodu niejawnych reguł konwersji liczb na wartości boolowskie. Więc możesz też pisać

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

napisać to bardziej zwięźle. Ale poprzednia wersja jest lepsza pod względem czytelności.

Możesz utworzyć maskę na podstawie doSetwartości:

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

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Teraz czek może wyglądać następująco:

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

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

Na niektórych architekturach !!może być skompilowany do gałęzi, dzięki czemu możesz mieć dwie gałęzie:

1. Normalizacja przez !!(expr)
2. Porównać do doSet

Zaletą mojej propozycji jest zagwarantowanie jednego oddziału.

Uwaga: upewnij się, że nie wprowadzasz niezdefiniowanego zachowania, przesuwając w lewo o więcej niż 30 (zakładając, że liczba całkowita to 32 bity). Można to łatwo osiągnąć za pomocąstatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Istnieje wiele sposobów wykonania tego testu:

Operator trójskładnikowy może generować kosztowne skoki:

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

Możesz także użyć konwersji logicznej, która może, ale nie musi być skuteczna:

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

Lub jego odpowiednik:

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

Jeśli mnożenie jest tanie, możesz uniknąć skoków za pomocą:

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

Jeśli nie flagsjest podpisany, a kompilator jest bardzo inteligentny, poniższy podział może się skompilować do prostej zmiany:

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

Jeśli architektura używa arytmetyki dopełniania dwóch, oto kolejna alternatywa:

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

Alternatywnie można zdefiniować flagsjako strukturę z polami bitowymi i zastosować znacznie prostszą czytelną składnię:

if (flags.amazing_flag != doSet)

Niestety, takie podejście jest zwykle lekceważone, ponieważ specyfikacja pól bitowych nie pozwala na precyzyjną kontrolę nad implementacją na poziomie bitów.