Существуют ли точки последовательности в выражении a^= b^= a^= b, или она не определена?

Question

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

int a = 10; 
int b = 42; 

a ^= b ^= a ^= b; /*Here*/ 

printf("a=%d, b=%d\n", a, b); 

Но я задаюсь вопросом, составные операторы присваивания, как ^= являются а не точки последовательности, не так ли? Означает ли это, что это на самом деле неопределенное поведение?

Answer 1

a ^= b ^= a ^= b; /*Here*/ 

Это неопределенное поведение.

Вы изменяете объект (a) более одного раза между двумя точками последовательности.

(С99, 6.5p2) «Между предыдущей и следующей точкой последовательности объект должен быть его сохраненное значение модифицированного не более одного раза в ходе оценки выражения.

Простые задания, а также соединения задания не вводить точку последовательности. Здесь есть точка последовательности перед выражением выражение заявления и после выражения утверждения.

последовательности точек приведены в приложении с (информативное) от c99 и c11 стандарта.

Answer 2

^= не являются точками последовательности, они

Они не являются.

Означает ли это, что это на самом деле неопределенное поведение?

Да, это так. Не используйте эту «умную» технику.

Answer 3

В этом выражении нет точек последовательности, поэтому он создает неопределенное поведение.

Вы можете это исправить тривиальным и сохранить большую часть лаконичности с помощью оператора запятой, который делает введение точек последовательности:

a ^= b, b ^= a, a ^= b; 

Answer 4

Порядка оценки ^= операторов корректно определен. Что не определено, так это порядок, в котором изменены a и b.

a ^= b ^= a ^= b; 

эквивалентно

a ^= (b ^= (a ^= b)); 

Оператор не может быть оценена, прежде чем ее аргументы оцениваются, так что, безусловно, будет выполнять a ^= b первый.

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

int a1 = a^b; 
int b1 = b^a1; 
int a2 = a^b1; 
a = a1; 
a = a2; 
b = b1; 

или это:

int a1 = a^b; 
int b1 = b^a1; 
a = a1; 
int a2 = a^b1; 
a = a2; 
b = b1; 

или даже это:

int a1 = a^b; 
int b1 = b^a1; 
int a2 = a^b1; 
a = a2; 
a = a1; 
b = b1; 

Если компилятор может выбрать только один из этих трех способов сделать вещи, это будет просто «неуказанное» поведение. Однако стандарт идет дальше и делает это «неопределенным» поведением, что в основном позволяет компилятору предположить, что он даже не может произойти.