Does 'a[i] = i;' always result in well defined behaviour?

Question

There are several interesting questions raised here regarding undefined behaviour in C. One of them is (slightly modified)

Does the following piece of code result in undefined behaviour?
int i = 0, *a = &i;   // Line 1
a[i] = i + 1;         // Line 2

Since there is no concrete answer to this part of the question there, and I am interested in knowing the behaviour in C++, I am raising it again here.

Rule #2 from Undefined Behavior and Sequence Points says

Furthermore, the prior value shall be accessed only to determine the value to be stored

Clearly in the example above, the value is being accessed twice: a[i] (lhs) and i (rhs), and only one of them (the rhs) determines the value to be stored.

Does Line 2 violate the rule above and result in undefined behaviour in C++03?

There is some confusion as to whether i is modified at Line 2?

Yes it is modified!

interjay · Accepted Answer · 2012-03-04T17:12:54.583

This will result in undefined behavior in C++03, and well-defined behavior in C++11.

C++03: Undefined Behvaior

From the C++03 standard, section 5 paragraph 4:

Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be accessed only to determine the value to be stored.

Note the second sentence: The previous value of i can only be used to determine the value to be stored. But here it is also used to determine the array index. So because this assignment will modify i, a[0] = i+1 is well defined, while a[i] = i+1 is not. Note that the assignment does not generate a sequence point: only the end of the full expression (the semicolon) does.

C++11: Well defined behavior:

C++11 got rid of the notion of sequence points, and instead defines which evaluations are sequenced before which.

From the standard, section 1.9 paragraph 15:

The value computations of the operands of an operator are sequenced before the value computation of the result of the operator. If a side effect on a scalar object is unsequenced relative to either another side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined.

Both operands of the assignment operator are sequenced before the actual assignment. So both a[i] and i+1 will be evaluated, and only then will i be modified. The result is well defined.

+ 1 for both C++03 and C++11 answers. – Seth Carnegie Mar 04 '12 at 17:05 — Seth Carnegie, Mar 04 '12 at 17:05

score 3 · Answer 2 · answered Mar 04 '12 at 15:40

3

int i = 0, *a = &i;

there is a sequence point between declarations, therefore no UB here. However take a note that it is a bad idea to declare/define variables that way. Any normal coding standard would tell you declare one variable per line.

a[i] = i;

The i is not changed in any way, therefore no UB here either.

answered Mar 04 '12 at 15:40

BЈовић

62,405
41
173
273

1

What about `a[i] = i + 1;` then? – Lazer Mar 04 '12 at 15:43
2

@Lazer: `i + 1` doesn't change the `i` either – Lightness Races in Orbit Mar 04 '12 at 15:43
@Lazer Still no, because `i` is still not modified. – BЈовић Mar 04 '12 at 15:44
The value of `i` (0) is assigned to `(&i)[i]`, but any modification to `i` must be the last thing that happens, so the expression is clean enough (if you accept `int *a = &i` is 'clean'). – Jonathan Leffler Mar 04 '12 at 15:44
4

`&a[i] == &i`, so `i` *is* modified, indirectly. – sth Mar 04 '12 at 15:45
@sth: No, comparision doesn't modify anything. – Xeo Mar 04 '12 at 15:46
1

@sth: Not between sequence points it isn't. Otherwise `i = i` would not be valid. Or `i = i + 1`. Or anything of that ilk. – Lightness Races in Orbit Mar 04 '12 at 15:46
@JonathanLeffler No, it's not. `a` is a pointer to int. Therefore, `a[i]` is a reference to the ith position. It would be UB if i was different from 0. But as it is, everything is fine. – BЈовић Mar 04 '12 at 15:47
1

@Lightness: The standard specifically allows expressions like `i = i + 1` despite there being no sequence point. See the quote in my answer. – interjay Mar 04 '12 at 16:43

score 2 · Answer 3 · answered Mar 04 '12 at 16:54

2

Let us decompose the expression a[i] = i + 1 will you ?

= -- [] -- a
  \     \_ i
   \
    \_ + -- i
         \_ 1

Effectively, a[i] refers to &i however note that neither a[i] nor i+1 modifies i. i is only modified when = (the assignment itself) is executed.

Since the operands of any function need be evaluated before this function takes effect, this is actually equivalent to:

void assign(int& address, int value) { address = value; }

assign(a[i], i + 1);

It is true that = is somewhat special in that it is built-in and does not result in a function call, still the evaluation of both operands are sequenced before the actual assignment, so they are first evaluated prior to i being modified, and a[i] (which points to i location) is being assigned to.

answered Mar 04 '12 at 16:54

Matthieu M.

287,565
48
449
722

What about interjay's answer which says that the previous value can only be accessed to determine the value to be stored? – Seth Carnegie Mar 04 '12 at 16:59
This is how things work in C++11, but not C++03 (although any reasonable C++03 compiler would probably implement things this way as well). See my updated answer. – interjay Mar 04 '12 at 17:06
@interjay: ah right, I gave never been too savvy on sequence points so I only based my answer on the latest Standard. Nice answer, thanks for being thorough. – Matthieu M. Mar 04 '12 at 18:22

score 0 · Answer 4 · answered Mar 04 '12 at 15:45

Undefined behavior in this case would only take place if you modify the same memory address without a sequence point between the modifications. Specifically, the C99 spec, section 6.5/2 states,

Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be accessed only to determine the value to be stored.

In your case no modification of the same memory address takes place between sequence points, therefore there is no undefined behavior.

Here `i` is being modified without a sequence point (semicolon is the only sequence point in Line 2 I think) — Lazer, Mar 04 '12 at 15:58

score 0 · Answer 5 · answered Mar 04 '12 at 16:24

I would like to point out one thing: a[i] = i does not always lead to well defined behaviour. The reason why the behaviour is well defined in the case specified, is because of the initial values i and a.

Let me elaborate:

int i = 1, *a = &i;   // Line 1, i initialized to anything other than 0
a[i] = i + 1;         // Line 2, all of a sudden we are in buffer over/underflow

For any other initial value of i we are accessing a different memory location from that of i itself, which produces undefined behaviour.

Actually when `a` points to a single integer `i`, it doesn't matter what the value of `i` is, `a[i] = i` is always undefined behavior (if `*(&i + i) = i` is UB that is, which, according to interjay's answer, it is) — Seth Carnegie, Mar 04 '12 at 17:00

score 0 · Answer 6 · answered Mar 04 '12 at 17:07

No it doesn't. The first line has a sequence point (the comma), so it is not undefined behaviour:

int i = 0, *a = &i;

The second line is perfectly normal.

a[i] = i + 1;

Since i + 1 creates a temporary value, i gets modified only once, on the assignment. This however would be undefined behaviour:

a[i] = i++;

Does 'a[i] = i;' always result in well defined behaviour?

6 Answers6

Linked