Порівнюючи трохи з булевим

Скажіть, у мене є набір прапорів, закодованих у 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 ((flags & AMAZING_FLAG) != doSet){

}

Але це насправді не працює, trueсхоже, дорівнює 0x01.

Отже, чи є акуратний спосіб трохи порівняти булевий?

Щоб перетворити будь-яке ненульове число в 1 (вірно), є стара хитрість: !двічі застосуйте оператор (не).

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)

У C можуть бути абревіатури через неявні правила перетворення чисел у булі значення. Тож ви могли також писати

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 біта). Це можна легко досягти за допомогою astatic_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)

На жаль, цей підхід, як правило, нахмурюється, оскільки специфікація бітових полів не дозволяє точно контролювати реалізацію рівня бітів.