Похоже на код

i.operator+=(i.operator ++());

Прекрасно работает в отношении точек последовательности. В разделе 1.9.17 стандарта C ++ ISO говорится о точках последовательности и оценке функций:

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

Это может указывать, например, на то, что i.operator ++() в качестве параметра для operator += имеет точку последовательности после его оценки. Короче говоря, поскольку перегруженные операторы являются функциями, применяются обычные правила последовательности.

Кстати, отличный вопрос! Мне очень нравится, как вы заставляете меня понимать все нюансы языка, который я уже думал, что знаю (и думал, что думал, что знаю). :-)

http://www.eelis.net/C++/analogliterals.xhtml Аналоговые литералы приходят в по моему мнению

  unsigned int c = ( o-----o
                     |     !
                     !     !
                     !     !
                     o-----o ).area;

  assert( c == (I-----I) * (I-------I) );

  assert( ( o-----o
            |     !
            !     !
            !     !
            !     !
            o-----o ).area == ( o---------o
                                |         !
                                !         !
                                o---------o ).area );

Как уже говорили другие, ваш пример i += ++i работает с определяемым пользователем типом, поскольку вы вызываете функции, а функции содержат точки последовательности.

С другой стороны, a[++i] = i не так повезло, если предположить, что a - это ваш базовый тип массива или даже определенный пользователем. Проблема в том, что мы не знаем, какая часть выражения, содержащего i, оценивается первой. Может случиться так, что ++i оценивается, передается operator[] (или необработанной версии), чтобы получить там объект, а затем значение i передается этому (что происходит после того, как i был увеличен). С другой стороны, возможно, сначала оценивается последняя сторона, сохраняется для последующего присвоения, а затем оценивается часть ++i.

Я думаю, это четко определено:

Из проекта стандарта C ++ (n1905) §1.9 / 16:

«Также существует точка последовательности после копирования возвращаемого значения и перед выполнением любых выражений за пределами функции13). Некоторые контексты в C ++ вызывают оценку вызова функции, даже если соответствующий синтаксис вызова функции не появляется в блоке преобразования. [Пример: оценка нового выражения вызывает одну или несколько функций выделения и конструктора; см. 5.3.4. Другой пример: вызов функции преобразования (12.3.2) может возникать в контекстах, в которых нет Появляется синтаксис вызова функции. - конец примера] Точки последовательности при входе в функцию и выходе из функции (как описано выше) являются характеристиками вызовов функций, как они оцениваются, независимо от синтаксиса выражения , который вызывает функцию, может быть. "

Обратите внимание на часть, которую я выделил жирным шрифтом. Это означает, что действительно есть точка последовательности после вызова функции приращения (i.operator ++()), но перед вызовом составного присваивания (i.operator+=).

Хорошо. Прочитав предыдущие ответы, я снова подумал о своем вопросе, особенно о той части, которую только Ной пытался answer, но я не полностью убежден в нем.

a[++i] = i;

Дело 1:

Если a - массив встроенного типа. Тогда то, что сказал Ной, верно. Это,

a [++ i] = i не так повезло, если предположить, что a - это ваш базовый тип массива, или даже определенный пользователем. Проблема в том, что мы не знаем, какая часть выражения, содержащего i, вычисляется первой.

Итак, a[++i]=i вызывает неопределенное поведение, или результат не указан. Как бы то ни было, это не совсем четкое определение!

PS: В приведенной выше цитате зачеркнутый, конечно же, мой.

Случай 2:

Если a является объектом определяемого пользователем типа, который перегружает operator[], то опять же есть два случая.

1. Если тип возврата перегруженной функции operator[] является встроенным, тогда снова a[++i]=i вызывает неопределенное поведение или результат не указан.
2. Но если тип возврата перегруженной функции operator[] является определяемым пользователем типом, то поведение a[++i] = i четко определено (насколько я понимаю), поскольку в этом случае a[++i]=i эквивалентно записи a.operator[](++i).operator=(i);, которая совпадает с a[++i].operator=(i);. То есть присваивание operator= вызывается для возвращенного объекта a[++i], который кажется очень четко определенным, поскольку к моменту возврата a[++i] ++i уже были оценены, а затем вернул < / em> объект вызывает operator= функцию, передавая ей обновленное значение i в качестве аргумента. Обратите внимание, что между этими двумя вызовами есть точка последовательности. И синтаксис гарантирует, что между этими двумя вызовами нет конкуренции, и operator[] будет вызываться первым, и, последовательно, аргумент ++i, переданный ему, также будет сначала оценен.