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

Это продолжение моего предыдущего ответа и содержит связанный с С++ 11 материал..

Предварительные требования: элементарное знание отношений (математика).

Верно ли, что в С++ 11 нет точек последовательности?

Да! Это очень верно.

Точки последовательности были заменены на Последовательность до и Последовательность после (и Непоследовательность и Неопределенно Sequenced) отношения в С++ 11.

Что именно происходит в этой статье?

Последовательность перед ^(§1.9/13) - это отношение, которое:

• Асимметричный
• Transitive

между оценками, выполненными одним thread и индуцирует строгий частичный порядок ¹

Формально это означает, что для любых двух оценок ^{(см. ниже)}A и B, если A секвенировано до B, тогда выполнение of A должно предшествовать выполнению B. Если A не секвенируется до B, а B не секвенируется до A, то A и B непересекаются ².

Оценки A и B являются неопределенно секвенированными, когда либо A секвенирован до B или B секвенирован до A, но не определено, какой ^{> 3}.

<суб > [ПРИМЕЧАНИЯ]суб > <Суб >
1: Строгий частичный порядок - это двоичное отношение "<" над множеством P, которое asymmetric и transitive, т.е. для всех A, B и c в P, мы имеем следующее:
_{........ (i). если a < b, затем ¬ (b < a) (asymmetry);........ (II). если a < b и b < c, тогда a < c (transitivity).
2: Выполнение неощутимых оценок может перекрываться.
3: Неопределенно упорядоченные оценки не могут пересекаться, но либо могут быть выполнены в первую очередь. Суб >}

В чем смысл слова "оценка" в контексте С++ 11?

В С++ 11 оценка выражения (или подвыражения) в общем случае включает в себя:

• вычисления значений (в том числе определение идентичности объекта для оценки glvalue и получение значения, ранее присвоенного объекту для оценка оценки) и

• инициирование побочных эффектов.

Теперь (§1.9/14) говорится:

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

• Тривиальный пример:

  int x;  x = 10;  ++x;

  Вычисление значения и побочный эффект, связанные с ++x, секвенируются после вычисления значения и побочного эффекта x = 10;

Итак, должно быть какое-то отношение между Undefined Поведением и вышеупомянутыми вещами, правильно?

Да! Правильно.

В (§1.9/15) было отмечено, что

За исключением тех случаев, когда отмечено, оценки операндов отдельных операторов и подвыражений отдельных выражений не подвержены последовательности ⁴.

Например:

int main()
{
     int num = 19 ;
     num = (num << 3) + (num >> 3);
} 

• Оценка операндов оператора + не зависит от друг друга.
• Оценка операндов операторов << и >> не зависит друг от друга.

_{4: В выражении, которое оценивается более одного раза во время выполнения программы, непересекающиеся и неопределенно упорядоченные оценки ее подвыражений не должны выполняться последовательно в разных оценках.Суб >}

(§1.9/15) Вычисления значений операндов оператор упорядочивается перед вычислением значения результата оператора.

Это означает, что в x + y вычисление значения x и y секвенировано перед вычислением значения (x + y).

Более важно

(§1.9/15) Если побочный эффект на скалярном объекте не влияет на

(a) другой побочный эффект на том же скалярном объекте

или

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

поведение undefined.

Примеры:

int i = 5, v[10] = { };
void  f(int,  int);

• i = i++ * ++i; // Undefined Behaviour
• i = ++i + i++; // Undefined Behaviour
• i = ++i + ++i; // Undefined Behaviour
• i = v[i++]; // Undefined Behaviour
• i = v[++i]: // Well-defined Behavior
• i = i++ + 1; // Undefined Behaviour
• i = ++i + 1; // Well-defined Behaviour
• ++++i; // Well-defined Behaviour
• f(i = -1, i = -1); // Undefined Behaviour (see below)

При вызове функции (независимо от того, является ли функция встроенной) каждое вычисление значения и побочный эффект, связанный с любым выражением аргумента, или с выражением postfix, обозначающим вызываемую функцию, секвенируются перед выполнением каждого выражения или оператора в тело вызываемой функции. [Примечание: Вычисления по значениям и побочные эффекты, связанные с разными выражениями аргумента, не имеют значения. - конечная нота]

Выражения (5), (7) и (8) не вызывают поведение Undefined. Ознакомьтесь с нижеследующими ответами для более подробного объяснения.

• Несколько операций preincrement для переменной в С++ 0x
• Непоследовательные вычисления значений

Заключительная записка:

Если вы обнаружите какой-либо недостаток в сообщении, оставьте комментарий. Power-users (С rep > 20000), пожалуйста, не стесняйтесь редактировать сообщение для исправления опечаток и других ошибок.

Точки последовательности

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

Оценки

Оценка чего-то означает применение семантики выполнения во время выражения. Существуют неоцененные выражения (операнды sizeof, некоторые операнды typeid и т.д.), Которые проверяют только тип выражения и не имеют смысла во время выполнения. Если выражение оценивается, оно может привести к значению, которое может означать считывание значений из объектов, или оно может просто оценить объект, не читая его значение (тогда оно остается lvalue, как при левом подвыражении присвоения). Кроме того, при необходимости он может создавать побочные эффекты. Оценка завершена, если ее значение известно, но до тех пор, пока не будет достигнута точка последовательности, предполагается, что побочные эффекты, полученные в результате оценки, все еще обрабатываются.

У вас есть точки последовательности после всех оценок, которые обычно необходимы для полной обработки, прежде чем обрабатываются некоторые другие выражения. Это

• После оценки a в a && b и a || b и a ? b : c. Также после оценки a в a, b - этот оператор называется "оператором запятой".
• Для вызова функции, после оценки аргументов вызова функции и перед началом оценки в теле функции.
• После оценки полного выражения (которое не было оценено как часть другого выражения). Примерами являются условия цикла, условия, значения переключателей и выражения.
• Непосредственно перед завершением функции (путем разворачивания функции по исключению или путем обычного возврата ее после (возможно) создания возвращаемого значения). Это гарантирует, что каждый побочный эффект в функции действительно был урегулирован и полностью обработан.

Побочные эффекты

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

Поток выполнения программы

С этими тремя терминами поток программы можно визуализировать следующим образом. На следующих диаграммах a E(X) указывает оценку (под) выражения x, a % указывает точку последовательности, а S(k, e) указывает на побочный эффект k на объект e. Если оценка должна считывать значение из именованного объекта (если x - это имя), оценка записывается как V(x), в противном случае она записывается как E(X). Побочные эффекты записываются справа и слева в выражения. Ребро между двумя выражениями означает, что верхнее выражение оценивается перед нижним выражением (обычно потому, что нижнее выражение зависит от значения или lvalue верхнего выражения).

Если вы посмотрите на два оператора выражения i++; i++;, вы можете отобразить следующую диаграмму

E(i++) -> { S(increment, i) }
   |
   %
   |
E(i++) -> { S(increment, i) }
   |
   %

Как можно видеть, есть две точки последовательности, и одна из них разделяет две модификации i. Интересны также аргументы вызова функции, хотя я опускаю диаграмму для этого

int c = 0;
int d = 0;
void f(int a, int b) { assert((a == c - 1) && (b == d - 1)); }
int main() { f(c++, d++); }

Утверждение прекрасно, потому что гарантировано, что при выполнении f тела выполняются побочные эффекты, полученные путем оценки аргументов: для этого c и d были полностью увеличены.

Рассмотрим выражение выражение i++ * j++;

{ S(increment, i) } <- E(i++)      E(j++) -> { S(increment, j) }
                           \       /
                            +--+--+
                               |
                         E(i++ * j++)
                               |
                               %

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

Конфликтные побочные эффекты

Чтобы предоставить максимальную свободу компилятора при генерации и оптимизации машинного кода, такие случаи, как умножение выше, не упорядочивают оценки подвыражений и не разделяют побочные эффекты, производимые ими, за исключением нескольких случаев, описанных выше. Это может привести к конфликтам, и С++ Standard отмечает поведение программ undefined, если они пытаются изменить один и тот же объект без промежуточной точки последовательности (на самом деле он применяется к скалярным объектам, поскольку другие объекты либо немодифицируются (массивы) или просто не применимы к этому правилу (объекты класса)). Поведение также undefined, если предыдущее значение считывается с объекта, но есть также модификация, как в i * i++

// This yields to undefined behavior!
// Left 'i' is not guaranteed to read new value:

    V(i)        E(i++) -> { S(increment, i) })
      \         /
       +---+---+
           |
       E(i * i++)
           |
           %

В качестве исключения он позволил прочитать значение объекта, если он необходим для вычисления нового значения. Это имеет место в i = i + 1

                V(i)        E(1)
                   \         /
                    +---+---+
                        |
  E(i)              E(i + 1)
     \                 /
      +-------+-------+
              |
        E(i = i + 1) -> { S(assign, i) }
              |
              %

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

Иногда значение считывается после того, как была выполнена модификация. Это относится к a = (b = 0), который в С++ будет записываться в b, а затем читать из b без промежуточной точки последовательности! Это, однако, прекрасно, потому что оно не читает предыдущее значение b, а новое значение. В этом случае побочный эффект назначения на b был завершен не только перед следующей точкой последовательности, но и перед чтением b, если это необходимо для назначения a для получения нового значения из b. В спецификации это отношение устанавливается явными ограничениями, в этом случае оно, в частности, относится к b = 0 и читает "Результат операции присваивания - это значение, сохраненное в левом операнде после выполнения присвоения, lvalue". Почему бы не указать последовательность, чтобы сделать это отношение? Поскольку точка последовательности имела бы нежелательный эффект, требуя, чтобы каждый побочный эффект, который случается при оценке левого и правого операндов, был полным, вместо того чтобы делать это только для назначения в случае, если его полученное значение l считывается из.

Закрывающие слова

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

С++ 17 (N4659) включает предложение Обновление оценки оценки выражений для Idiomatic С++ который определяет более строгий порядок оценки выражения.

В частности, добавлено следующее предложение:

8.18 Операторы присваивания и составного присваивания:
....

Во всех случаях назначение упорядочивается после значения вычисление правого и левого операндов и перед вычислением значения выражения присваивания. Правильный операнд упорядочен перед левым операндом.

Он делает несколько случаев ранее допустимого поведения undefined, включая тот, о котором идет речь:

a[++i] = i;

Однако несколько других подобных случаев по-прежнему приводят к поведению undefined.

В N4140:

i = i++ + 1; // the behavior is undefined

Но в N4659

i = i++ + 1; // the value of i is incremented
i = i++ + i; // the behavior is undefined

Конечно, использование компилятора, совместимого с С++ 17, не обязательно означает, что нужно начинать писать такие выражения.

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

f (a,b)

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

В C99(ISO/IEC 9899:TC3) который, по-видимому, отсутствует в этом обсуждении, до сих пор сделаны следующие steteents относительно порядка оценки.

[...] порядок вычисления подвыражений и порядок возникновения побочных эффектов не определены. (Раздел 6.5 с. 67)

Порядок оценки операндов не указан. Если предпринята попытка изменить результат оператора присваивания или получить к нему доступ после следующей точки последовательности, поведение [sic] не определено (Раздел 6.5.16, стр. 91).