Сравнение немного с логическим

Скажем, у меня есть набор флагов, закодированных в uint16_t flags. Например, AMAZING_FLAG = 0x02. Теперь у меня есть функция. Эта функция должна проверить, хочу ли я изменить флаг, потому что, если я хочу это сделать, мне нужно записать на флэш-память. И это дорого. Поэтому я хочу чек, который говорит мне, flags & AMAZING_FLAGравен ли doSet. Это первая идея:

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

Это не интуитивное утверждение if. Я чувствую, что должен быть лучший способ, что-то вроде:

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

}

Но это на самом деле не работает, trueпохоже, равно 0x01.

Итак, есть ли хороший способ сравнить немного с логическим значением?

Чтобы преобразовать любое ненулевое число в 1 (true), существует старый прием: !дважды примените оператор (not).

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

Вам необходимо преобразовать битовую маску в логическое выражение, которое в C эквивалентно значениям 0или 1.

• (flags & AMAZING_FLAG) != 0, Самый распространенный способ.

• !!(flags & AMAZING_FLAG), Несколько распространенный, также хорошо, чтобы использовать, но немного загадочный.

• (bool)(flags & AMAZING_FLAG), Современный C-путь только от C99.

Возьмите любой из приведенных выше вариантов, затем сравните его с вашим логическим значением, используя !=или ==.

С логической точки зрения, flags & AMAZING_FLAGэто всего лишь битовая операция, маскирующая все остальные флаги. Результатом является числовое значение.

Чтобы получить логическое значение, вы должны использовать сравнение

(flags & AMAZING_FLAG) == AMAZING_FLAG

и теперь можно сравнить это логическое значение с doSet.

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

В Си могут быть сокращения из-за неявных правил преобразования чисел в логические значения. Таким образом, вы могли бы также написать

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

написать это более кратко. Но предыдущая версия лучше с точки зрения читабельности.

Вы можете создать маску на основе doSetзначения:

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

uint16_t set_mask = doSet << AMAZING_FLAG_IDX;

Теперь ваш чек может выглядеть так:

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

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

На некоторых архитектурах !!может быть скомпилирован в ветвь, и тем самым у вас может быть две ветки:

1. Нормализация по !!(expr)
2. По сравнению с doSet

Преимуществом моего предложения является гарантированная единая ветка.

Примечание: убедитесь, что вы не вводите неопределенное поведение, сдвигая влево более чем на 30 (при условии, что целое число составляет 32 бита). Это может быть легко достигнутоstatic_assert(AMAZING_FLAG_IDX < sizeof(int)*CHAR_BIT-1, "Invalid AMAZING_FLAG_IDX");

Есть несколько способов выполнить этот тест:

Тернарный оператор может генерировать дорогостоящие переходы:

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

Вы также можете использовать логическое преобразование, которое может быть или не быть эффективным:

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

Или его эквивалентная альтернатива:

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

Если умножение дешево, вы можете избежать скачков с:

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

Если он flagsне подписан, а компилятор очень умен, приведенное ниже разделение может скомпилировать простой сдвиг:

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

Если в архитектуре используется арифметика с дополнением до двух, здесь есть еще одна альтернатива:

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

Альтернативно, можно определить flagsкак структуру с битовыми полями и использовать намного более простой читаемый синтаксис:

if (flags.amazing_flag != doSet)

Увы, этот подход обычно не одобряется, потому что спецификация битовых полей не позволяет точно контролировать реализацию битового уровня.