Sequence point


A sequence point defines any point in a computer program's execution at which it is guaranteed that all side effects of previous evaluations will have been performed, and no side effects from subsequent evaluations have yet been performed. They are often mentioned in reference to C and C++, because they are a core concept for determining the validity and, if valid, the possible results of expressions. Adding more sequence points is sometimes necessary to make an expression defined and to ensure a single valid order of evaluation.
With C++11, usage of the term sequence point has been replaced by sequencing. There are three possibilities:
  1. An expression's evaluation can be sequenced before that of another expression, or equivalently the other expression's evaluation is sequenced after that of the first.
  2. The expressions' evaluation is indeterminately sequenced, meaning one is sequenced before the other, but which is unspecified.
  3. The expressions' evaluation is unsequenced.
The execution of unsequenced evaluations can overlap, with catastrophic undefined behavior if they share state. This situation can arise in parallel computations, causing race conditions. However, it can already arise in simple non-concurrent situations like + , where part of the assignment to a may happen before b = a, and the rest afterwards, such that after evaluation of the expression, b may contain a meaningless intermediate state of a.

Examples of ambiguity

Consider two functions f and g. In C and C++, the + operator is not associated with a sequence point, and therefore in the expression f+g it is possible that either f or g will be executed first. The comma operator introduces a sequence point, and therefore in the code f,g the order of evaluation is defined: first f is called, and then g is called.
Sequence points also come into play when the same variable is modified more than once within a single expression. An often-cited example is the C expression i=i++, which apparently both assigns i its previous value and increments i. The final value of i is ambiguous, because, depending on the order of expression evaluation, the increment may occur before, after, or interleaved with the assignment. The definition of a particular language might specify one of the possible behaviors or simply say the behavior is undefined. In C and C++, evaluating such an expression yields undefined behavior. Other languages, such as C#, define the precedence of the assignment and increment operator in such a way that the result of the expression i=i++ is guaranteed.

Sequence points in C and C++

In C and C++, sequence points occur in the following places.
  1. Between evaluation of the left and right operands of the &&, || , and comma operators. For example, in the expression, all side effects of the sub-expression are completed before any attempt to access.
  2. Between the evaluation of the first operand of the ternary and the second or third operand. For example, in the expression there is a sequence point after the first, meaning it has already been incremented by the time the second instance is executed.
  3. At the end of a full expression. This category includes expression statements, return statements, the controlling expressions of,,, or - statements, and all three expressions in a statement.
  4. Before a function is entered in a function call. The order in which the arguments are evaluated is not specified, but this sequence point means that all of their side effects are complete before the function is entered. In the expression, is called with a parameter of the original value of, but is incremented before entering the body of. Similarly, and are updated before entering and respectively. However, it is not specified in which order,, are executed, nor in which order,, are incremented. If the body of accesses the variables and, it might find both, neither, or just one of them to have been incremented.
  5. At a function return, after the return value is copied into the calling context.
  6. At the end of an initializer; for example, after the evaluation of in the declaration.
  7. Between each declarator in each declarator sequence; for example, between the two evaluations of in.
  8. After each conversion associated with an input/output format specifier. For example, in the expression, there is a sequence point after the is evaluated and before printing.