C/C++ intentional out of range indexing

Question

Say I have an array like so:

int val[10];

and I intentionally index it with everything from negative values to anything higher than 9, but WITHOUT using the resulting value in any way. This would be for performance reasons (perhaps it's more efficient to check the input index AFTER the array access has been made).

My questions are:

1. Is it safe to do so, or will I run into some sort of memory protection barriers, risk corrupting memory or similar for certain indices?
2. Is it perhaps not at all efficient if I access data out of range like this? (assuming the array has no built in range check).
3. Would it be considered bad practice? (assuming a comment is written to indicate we're aware of using out of range indices).

Answer 1

It is undefined behavior. By definition, undefined means "anything could happen." Your code could crash, it could work perfectly, it could bring about peace and harmony amongst all humans. I wouldn't bet on the second or the last.

Answer 2

It is Undefined Behavior, and you might actually run afoul of the optimizers.

Imagine this simple code example:

int select(int i) {
    int values[10] = { .... };

    int const result = values[i];

    if (i < 0 or i > 9) throw std::out_of_range("out!");

    return result;
}

And now look at it from an optimizer point of view:

• int values[10] = { ... };: valid indexes are in [0, 9].

• values[i]: i is an index, thus i is in [0, 9].

• if (i < 0 or i > 9) throw std::out_of_range("out!");: i is in [0, 9], never taken

And thus the function rewritten by the optimizer:

int select(int i) {
    int values[10] = { ... };

    return values[i];
}

For more amusing stories about forward and backward propagation of assumptions based on the fact that the developer is not doing anything forbidden, see What every C programmer should know about Undefined Behavior: Part 2.

EDIT:

Possible work-around: if you know that you will access from -M to +N you can:

• declare the array with appropriate buffer: int values[M + 10 + N]
• offset any access: values[M + i]

Answer 3

As verbose said, this yields undefined behavior. A bit more precision follows.

5.2.1/1 says

[...] The expression E1[E2] is identical (by definition) to *((E1)+(E2))

Hence, val[i] is equivalent to *((val)+i)). Since val is an array, the array-to-pointer conversion (4.2/1) occurs before the addition is performed. Therefore, val[i] is equivalent to *(ptr + i) where ptr is an int* set to &val[0].

Then, 5.7/2 explains what ptr + i points to. It also says (emphasis are mine):

[...] If both the pointer operand and the result point to elements of the same array object, or one past the last element of the array object, the evaluation shall not produce an overflow; otherwise, the behavior is undefined.

In the case of ptr + i, ptr is the pointer operand and the result is ptr + i. According to the quote above, both should point to an element of the array or to one past the last element. That is, in the OP's case ptr + i is a well defined expression for all i = 0, ..., 10. Finally, *(ptr + i) is well defined for 0 <= i < 10 but not for i = 10.

Edit:

I'm puzzled to whether val[10] (or, equivalently, *(ptr + 10)) yields undefined behavior or not (I'm considering C++ not C). In some circumstances this is true (e.g. int x = val[10]; is undefined behavior) but in others this is not so clear. For instance,

int* p = &val[10];

As we have seen, this is equivalent to int* p = &*(ptr + 10); which could be undefined behavior (because it dereferences a pointer to one past the last element of val) or the same as int* p = ptr + 10; which is well defined.

I found these two references which show how fuzzy this question is:

May I take the address of the one-past-the-end element of an array?

Take the address of a one-past-the-end array element via subscript: legal by the C++ Standard or not?

Answer 4

If you put it in a structure with some padding ints, it should be safe (since the pointer actually points to "known" destinations). But it's better to avoid it.

struct SafeOutOfBoundsAccess
{ 
    int paddingBefore[6];
    int val[10];
    int paddingAfter[6];
};

void foo()
{
    SafeOutOfBoundsAccess a;
    bool maybeTrue1 = a.val[-1] == a.paddingBefore[5];
    bool maybeTrue2 = a.val[10] == a.paddingAfter[0];
}