поведение bool с небулевыми операторами

Стандартный говорит:

4.5-4 «Интегральные продвижения»

Значение типа bool может быть преобразовано в rvalue типа int, с ложным становится нулевым и истинным становится единым.

5.17-7 «Операторы присваивания»

Поведение выражения форма E1 op = E2 эквивалентна E1 = E1 op E2, за исключением того, что E1 оценивается только однажды. В + = и - = E1 должен либо иметь арифметический тип, либо быть указатель на возможно cvqualified полностью определенный тип объекта. В целом в других случаях E1 должен иметь арифметические тип.

4.12-1 "Булевы преобразования"

Значение r арифметики, перечисления, указатель или указатель на тип элемента может быть преобразованным в rvalue типа булево. Нулевое значение, нулевой указатель значение или значение указателя нулевого члена преобразован в ложь; любое другое значение преобразовано в истину.

Таким образом, это означает, что

b1 += b2

Где b1 и b2 являются логическими, будет эквивалентно

b1 = b1 + b2

И b1 и b2 будут преобразованы в целые числа 0/1, а затем преобразованы обратно в логические по правилу, что истинно все, кроме 0.

Таким образом, таблица истинности

            true   false
true     true   true
false    true   false

, так что + = действительно работает как || = согласно стандарту. Однако это, вероятно, запутает других программистов, поэтому я бы все равно этого избегал.

Не могли бы вы просто использовать тернарный оператор?

old_value =! Old_value? possible_new_value: old_value;

Не используйте | = и & = с bools. Они могут работать большую часть времени, но это все равно неправильно. Обычно тип bool - это просто прославленный int или char. В более старом коде, с которым я работал, BOOL просто определяется типом int или char. В этих случаях вы можете получить неправильный ответ, если каким-то образом были изменены биты (например, 1 & 2 равно 0 (ложь)). И я не уверен, но я думаю, что результат побитовых операторов будет int, даже для bools.

Одно отличие состоит в том, что логические операторы, такие как || , гарантируют порядок вычисления и обеспечивают сокращение, в отличие от побитовых и арифметических операторов.

Я считаю, что компилятор будет обрабатывать нелогические операторы путем преобразования bools в числовые значения (0, 1), применяя оператор и конвертируя обратно. Эти преобразования строго определены стандартом, например:

r-значение арифметики, перечисления, указателя или указателя на тип элемента может быть преобразовано в r-значение типа bool. Нулевое значение, значение нулевого указателя или значение указателя нулевого члена преобразуются в ложь, любое другое значение преобразуется в истину.

if (!old_value)
    old_value = possible_new_value;

Это прямой эквивалент исходного состояния. Он мог бы генерировать более простой код, поскольку он не всегда будет присваиваться old_value - но я не ожидал бы, что разницу в производительности будет легко измерить в большой программе.

Я считаю, что стандарт явно определяет истину и ложь как 1 и 0, поэтому вы можете безопасно использовать побитовые операторы для значений bool . Другие типы, которые могут неявно обрабатываться как bools в другом контексте, должны быть явно преобразованы, чтобы это работало надежно.

Я видел, как компилятор Microsoft генерирует уродливое предупреждение каждый раз, когда вы делаете это, потому что он думает, что существует опасность неявного преобразования результат int возвращается в bool.

Грязное взлом макросов:

#define UPDATE(x) x = x

UPDATE(old_value) || possible_new_value;

Но я не рекомендую это вообще. Подобные макросы - очень плохая идея по нескольким причинам.

Более нормальная функция, но без короткого замыкания:

bool set_or(bool &old, bool value) {
  return (old = old || value);
}

...

bool v = false;
set_or(v, true);