Эквивалентность "a @= b" и "a = a @b"

Часто обсуждается (действительно, я думаю, что даже стандарт ссылается на него), что a @= b и a = a @ b эквивалентны. Здесь я использую @ для обозначения диапазона символов, таких как & и ^.

Однако я сомневаюсь, что они эквивалентны во время выполнения, особенно если a является атомным типом. Например:

std::atomic_int a;
a ^= 1;

(который является атомным способом переключения a), рассматривается как эквивалентный

a = a ^ 1;

Но этот второй способ состоит из не атома из-за назначения.

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

Правильно ли я?

Ответ 1

Стандарт языка определяет только поведение встроенного а не "пользовательские" перегрузки. И из с точки зрения языка, нет встроенного оператора для std::atomic_int (который формально является "определяемым пользователем типом" ); std::atomic_int является typedef для std::atomic<int>, который определяет количество перегрузок [email protected]=, но не просто @. Итак, для

std::atomic_int i;
i ^= 1;

вторая строка будет:

i.operator^=( 1 );

но для:

std::atomic_int i;
i = i ^ 1;

вторая строка будет:

i.operator=( i.operator int() ^ 1 );

Можно утверждать, что это часть того, что подразумевается под "аргумент левой руки оценивается дважды, а не один раз". В более общем плане, однако, определения для перегруженных операторы - это то, что хотел автору оператора: operator+= может (насколько это касается языка) фактически вычитают, даже когда operator+ добавлен. (У меня есть пара случаев, когда operator+ действительно operator+=. Это обычно не хорошая идея, и в моем случае это происходит только с классы, специально предназначенные для использования с std::accumulate, и задокументировано, чтобы использоваться только в этом случае.) Стандарт просто не ограничивает определенные пользователем операторы

Ответ 2

Вы правы. На самом деле, они даже не гарантируются как эквивалентные в общем неатомном случае, так как класс может обеспечить разные перегрузки для += и +, которые полностью независимы.

Ответ 3

Встроенные операторы имеют эту эквивалентность, за исключением того, что a @= b оценивает только a один раз, а a = a @ b оценивает его дважды.

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

Ответ 4

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