Побочные эффекты a = (b = c)

В связи с этой темой хотелось бы уточнить:
гарантируется ли, что запись в b будет раньше, чем запись в a?
ИМХО, в C99 - нет (6.5.16.3: "The side effect of updating the stored value of the left operand shall occur between the previous and the next sequence point"). Насчёт C11 не уверен, но вроде тоже нет (в отличие от C++11, где в 5.17.1 явно написано, что "assignment is sequenced... before the value comutation of the assignment expression").

0

Скобки имеют приоритет выше, чем присваивание, значит, б присваивается с и присваивается а

0

Да оно и без скобок гарантируется - оператор = выполняется справа налево, то есть сначала будет вычеслено b = c, и только за тем a = b. Перечитайте главу "Приоритет и очерёдность вычислений" в КиР, там подробно описаны ситуации, когда очерёдность вычислений не определена. Это не тот случай.

0

Сообщение от easybudda то есть сначала будет вычеслено b = c, и только за тем a = b

Вычислено - это да. То есть результатом b = c будет то, что было в c, и это будет rvalue. Дальше будет вычислен результат a = (b = c). Но запись в a и в b - это побочный эффект, который может произойти в любой время между точками следования (C99).

An assignment operator stores a value in the object designated by the left operand. An assignment expression has the value of the left operand after the assignment, but is not an lvalue. The type of an assignment expression is the type of the left operand unless the left operand has qualified type, in which case it is the unqualified version of the type of the left operand. The side effect of updating the stored value of the left operand shall occur between the previous and the next sequence point.

0

Сообщение от Somebody гарантируется ли, что запись в b будет раньше, чем запись в a?

сначала вычисляются операнды первого присваивания
правый операнд является присваиванием, поэтому при его вычислении вычисляются его операнды
после вычисления операндов второго присваивания оно выполняется и операция возвращает новое содержимое левого операнда
после этого правый операнд вычислен и выполняется первое присваивание

Сообщение от easybudda Перечитайте главу "Приоритет и очерёдность вычислений" в КиР

не перечитать надо, а просто прочитать книгу, потому что там куча примеров с таким присваиванием без всяких скобок

Сообщение от Somebody ИМХО, в C99 - нет (6.5.16.3

такого пункта там нет, есть 6.5.16 и в нём третий блок

я так понял, что побочные эффекты, получающиеся при записи в левое значение, гарантированно происходят уже после того как операнды вычислены (это уточнено в C11)

Сообщение от Somebody Хм... Вообще, мне кажется, что даже C 1 2 int d = 10; printf("%d %d", d = 10, d = 10); это уже undefined behaviour.

порядок вычисления аргументов функции не определён, но гарантируется, что каждый аргумент будет вычислен в значение и оно будет передано
так что никакого undefined behavior

1

Для начала: я не говорю, что здесь операдны могут вычисляться не в том порядке. Можно и без скобок, конечно. Вопрос только в порядке записи. А истина всё-таки в стандарте, а не в K&R...

Сообщение от accept после вычисления операндов второго присваивания оно выполняется и операция возвращает новое содержимое левого операнда

Вроде бы, действительно, значение левого операнда после присваивания:

An assignment operator stores a value in the object designated by the left operand. An assignment expression has the value of the left operand after the assignment, but is not an lvalue.

Но в таком случае предложение:

The side effect of updating the stored value of the left operand shall occur between the previous and the next sequence point.

кажется избыточным, ну да ладно.
Порядок записи будет важен, если переменные volatile. И тогда получается такой интересный момент:
Здесь в a в теории должно записаться то, что прочитается из b, а не 0? Интересно... Вот, нашёл обсуждения на эту тему:
http://stackoverflow.com/quest... b-1-read-b
http://stackoverflow.com/quest... d-volatile
В C11 на этот счёт появилось примечание:

111) The implementation is permitted to read the object to determine the value but is not required to, even when the object has volatile-qualified type.

Далее:

Сообщение от accept порядок вычисления аргументов функции не определён, но гарантируется, что каждый аргумент будет вычислен в значение и оно будет передано так что никакого undefined behavior

Но там два раза изменение d, это попадает под "Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression", даже если одно и то же значение пишется, не?

Теперь к тому, с чего всё началось в предыдущей теме, более конкретно:
C99: независимо от того, что в каком порядке пишется, всё равно будет изменение объекта более одного раза между точками следования - undefined behavior. Так?
C11:

An assignment operator stores a value in the object designated by the left operand. An assignment expression has the value of the left operand after the assignment,111) but is not an lvalue. The type of an assignment expression is the type the left operand would have after lvalue conversion. The side effect of updating the stored value of the left operand is sequenced after the value computations of the left and right operands. The evaluations of the operands are unsequenced.

Тоже undefined, получается.

0

Сообщение от Somebody Теперь к тому, с чего всё началось в предыдущей теме, более конкретно: C 1 a -= b = (a += b) - b; C99: независимо от того, что в каком порядке пишется, всё равно будет изменение объекта более одного раза между точками следования - undefined behavior. Так?

Не так. Сначала будет вычеслено a += b за тем b = a - b а за тем a -= b. В результате a и b поменяются значениями. Если ваш компилятор сделает что-то другое - избавьтесь от него.
Другой случай:
у меня вывело 2 1, но я бы не стал ставить на то, что так будет на любой системе при любом компиляторе, даже не смотря на http://codepad.org/trPIu370

0

Сообщение от easybudda Не так. Сначала будет вычеслено a += b за тем b = a - b а за тем a -= b. В результате a и b поменяются значениями. Если ваш компилятор сделает что-то другое - избавьтесь от него.

Как же насчёт того, что нельзя изменять объект больше одного раза между точками следования? По такой логике
это тоже нормально? Но это 100% ub, потому что это пример из стандарта.

0

Сообщение от Somebody это тоже нормально? Но это 100% ub, потому что это пример из стандарта.

Если можно, раздел укажите, да и сам стандарт, а то Вы их тут уже несколько обозначили... И кстати, откровенно не понимаю, что не так в этом выражении. Сначала текущее значение i увеличивается на единицу, за тем к получившемуся значению прибавляется константа (1 в этом случае) и всё это веселье (результат сложения) присваивается переменной i. А какие ещё есть варианты? По сути тоже самое, что
Беда была бы, если бы было
т.к. тут результат зависит от того, выражение в каких скобках посчитается первым.

0

Дополнение к тому большому посту:

Сообщение от Somebody Вроде бы, действительно, значение левого операнда после присваивания

Кстати, если бы и правда это был единственно возможный вариант, то было бы странно, что i = ++i + 1 приведено в примере как undefined, потому что оно чисто формально не соответствует пунтку про модификацию между точками следования без какого-либо дополнительного здравого обоснования. Так что, имхо, это следует читать так же, как и в C11.

Сообщение от easybudda Если можно, раздел укажите, да и сам стандарт, а то Вы их тут уже несколько обозначили

C99, C11.
http://www.open-std.org/jtc1/s... /n1256.pdf
https://github.com/maeikei/por... /n1570.pdf
Примечание в начале раздела 6.5 и в том, и в другом.
Допустим, C99: не так как минимум то, что это формально не соответствует фразе "Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression.72) Furthermore, the prior value shall be read only to determine the value to be stored.73)".

0

Сообщение от Somebody Примечание в начале раздела 6.5

Точно, увидел. Странно как-то... Но спорить глупо - стандарт всё-таки...

0

Сообщение от Somebody А истина всё-таки в стандарте, а не в K&R...

К&R2 написана по стандарту

Сообщение от Somebody Здесь в a в теории должно записаться то, что прочитается из b, а не 0?

всё то же самое будет
volatile означает, что значение может меняться

Сообщение от Somebody 111) The implementation is permitted to read the object to determine the value but is not required to

в любом случае у операции есть возвращаемое значение, которое и будет использоваться дальше

Сообщение от Somebody Но там два раза изменение d, это попадает под "Between the previous and next sequence point

previous and next sequence point - это всё внутри одной операции присваивания

Сообщение от Somebody C 1 a -= b = (a += b) - b;

и всё в кучу мешать нельзя, простое и составное по-разному работают

0

Сообщение от accept К&R2 написана по стандарту

Не по C99 или C11...

Сообщение от accept всё то же самое будет volatile означает, что значение может меняться

В b записывается 0. Что должно записаться в a? Ноль как результат присваивания или b как значение левого операнда после присваивания? В случае с volatile это же не обязательно будет 0. Может быть, результат чтения из b вообще даже никогда не бывает нулём...

Сообщение от accept в любом случае у операции есть возвращаемое значение, которое и будет использоваться дальше

Есть, но откуда это за значение берётся? В примечании в C11 не зря же оговаривается "even when the object has volatile-qualified type" - потому что при написании такого кода может быть важно это знать.

Сообщение от accept previous and next sequence point - это всё внутри одной операции присваивания

The following are the sequence points described in 5.1.2.3: — The call to a function, after the arguments have been evaluated (6.5.2.2). — The end of a full declarator: declarators (6.7.5); — Immediately before a library function returns (7.1.4). — After the actions associated with each formatted input/output function conversion specifier (7.19.6, 7.24.2). — Immediately before and immediately after each call to a comparison function, and also between any call to a comparison function and any movement of the objects passed as arguments to that call (7.20.5).

Где sequence point'ы? Перед присваиваниями - это после объявления переменных. После присваиваний - это перед вызовом функции. Между ними - не вижу где...

Сообщение от accept и всё в кучу мешать нельзя, простое и составное по-разному работают

Ладно, если взять
то сказанное применимо и к этому случаю, тут изменяется a и при этом она же в другом месте читается.

0

не углубляясь в раскаленную атмосферу страстей...
никогда не понимал этих срачей и холиваров а-ля i = i++ + ++i; зачем все усложнять и делать код чертвоски запутанным, неоднозначным и непонятным? KISS же. не уверен в инструкции которую написал? - прочти документацию! не помогло? - сделай проще! не можеш проще? - ты _________________ а не программист(вписаить прилагательное в зависимости от ваших морально-этических взглядов и принципов).
не уверен в этом? документация непомогла?
сделай, то в чем ты уверен.
тоже не уверен? сделай еще проще!
...в конечном счете все сведется к асемблерному mov, коих в любом случае будет 3 штуки (если я не ошибаюсь).
языки же предоставляют несколько путей для решения задач(имею ввиду на уровне инструкций), то есть одну и ту же задачу можно решить несколькими способами(как было продемонстрировано выше). зачем усложнять?

1

Сообщение от lowercase C 1 2 int x, y, z; x = y = z = 0;

Нет проблем, более чем уверен. Теперь возьмём
На что это заменить? Вариант 1:
Вариант 2:
А ведь это совсем разные вещи, если x, y, z - например, порты ввода/вывода.

0

все зависит от результата который вы хотите получить.

1

Сообщение от lowercase все зависит от результата который вы хотите получить.

А, понял мысль. Может быть, это и плохо так возиться с теорией, но она меня всё равно интересует...

0

Сообщение от Somebody А, понял мысль. Может быть, это и плохо так возиться с теорией, но она меня всё равно интересует...

первый ответ был на вопрос по поводу a = (b = c). Я разделяю ваш сарказм(?), и скажу в данном случае моей компетентности может не хватить.
я имел ввиду, что если вам нужно занулить занения переменных. но вы не уверенны x = y = z = 0; то ведь это можно сделать простым и более очевидным способом
даже в сулчае с volatile(?)
то есть тут вы получите то, что ожидаете.
на этом моя компетенция закачивается и как быть в инном случае я уже, к сожалению, сказать немогу. могу лишь делать некоторые предположения, которые, не факт, что будут верными.

0

Я про то, что понятно, что если нужно написать код, который что-то делает, то можно написать так, что ни у кого не будет вопросов, как он работает. Проблемы начинаются, когда, код уже есть, а что он должен делать - неясно. Например, при написании компилятора.

0