Считайте эту тему продолжением следующей темы:

Предыдущая партия
Неопределенное поведение и точки последовательности

Давайте еще раз вернемся к этому забавному и запутанному выражению (выделенные курсивом фразы взяты из темы выше * улыбка *):

i += ++i;

Мы говорим, что это вызывает неопределенное поведение. Я предполагаю, что, говоря это, мы неявно предполагаем, что type of iявляется одним из встроенных типов.

Что делать , если тип из iявляется определенный пользователем тип? Скажите, что его тип Indexопределен позже в этом посте (см. Ниже). Будет ли он по-прежнему вызывать неопределенное поведение?

Если да, то почему? Разве это не эквивалентно написанию i.operator+=(i.operator++());или даже синтаксически проще i.add(i.inc());? Или они тоже вызывают неопределенное поведение?

Если нет, то почему? В конце концов, объект iизменяется дважды между последовательными точками последовательности. Вспомните эмпирическое правило: выражение может изменять значение объекта только один раз между последовательными "точками последовательности" . И если i += ++iэто выражение, то оно должно вызывать неопределенное поведение. Если да, то его эквиваленты, i.operator+=(i.operator++());а i.add(i.inc());также должны вызывать неопределенное поведение, которое кажется неправдой! (насколько я понимаю)

Или i += ++iэто не выражение для начала? Если да, то что это такое и каково определение выражения ?

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

Кстати, а как насчет этого выражения?

//Consider two cases:
//1. If a is an array of a built-in type
//2. If a is user-defined type which overloads the subscript operator!

a[++i] = i; //Taken from the previous topic. But here type of `i` is Index.

Вы также должны учитывать это в своем ответе (если вы точно знаете его поведение). :-)

Является

++++++i;

четко определен в C ++ 03? Ведь вот это,

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

class Index
{
    int state;

    public:
        Index(int s) : state(s) {}
        Index& operator++()
        {
            state++;
            return *this;
        }
        Index& operator+=(const Index & index)
        {
            state+= index.state;
            return *this;
        }
        operator int()
        {
            return state;
        }
        Index & add(const Index & index)
        {
            state += index.state;
            return *this;
        }
        Index & inc()
        {
            state++;
            return *this;
        }
};

Похоже на код

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+=).

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

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уже были оценены, а затем возвращаемый объект вызывает operator=функцию, передавая ему обновленное значение iв качестве аргумента. Обратите внимание, что между этими двумя вызовами есть точка последовательности . А синтаксис гарантирует отсутствие конкуренции между этими двумя вызовами, иoperator[]будет вызван первым, и последовательно ++iпереданный ему аргумент также будет сначала оценен.

Думайте об этом как о том, someInstance.Fun(++k).Gun(10).Sun(k).Tun();что каждый последующий вызов функции возвращает объект определенного пользователем типа. Мне эта ситуация кажется больше такой:, eat(++k);drink(10);sleep(k)потому что в обеих ситуациях существует точка последовательности после каждого вызова функции.

Пожалуйста, поправьте меня, если я ошибаюсь. :-)