Can you do arithmetic on a char* pointing at another object [duplicate]

Question

This is a common way to read the bytes of an trivially copyable object

Object obj;
auto p = reinterpret_cast<char*>(&obj);
for(size_t i = 0; i < sizeof(obj); i++)
    consume(p[i]);

The problem isn't with strict-aliasing, char* is allowed to alias anything. The problem is with this passage from [expr.add]

When an expression that has integral type is added to or subtracted from a pointer, the result has the type of the pointer operand. If the expression P points to element x[i] of an array object x with n elements, the expressions P + J and J + P (where J has the value j) point to the (possibly-hypothetical) element x[i + j] if 0 ≤ i + j ≤ n; otherwise, the behavior is undefined. Likewise, the expression P - J points to the (possibly-hypothetical) element x[i − j] if 0 ≤ i − j ≤ n; otherwise, the behavior is undefined.

Where hypothetical element refers to

A pointer past the last element of an array x of n elements is considered to be equivalent to a pointer to a hypothetical element x[n] for this purpose

Which is to say, it is only legal if the arithmetic is on a pointer pointing at an array, and the result is still within its range.

However, there is clearly no char[sizeof(Object)] here, can we do arithmetic on that pointer?

Note that a legal solution to reading bytes of an object is to std::memcpy the object. But if that is the only solution, it begs to ask, why allow char* aliasing if you can barely do anything with it?

Answer 1

The pointer arithmetic should be legal according to the quotes. An Object instance obj can be viewed as char[sizeof(Object)]. So, it is an array of n elements (note that n is sizeof(Object)). Standard allows to do pointer arithmetic in bounds of this array plus one hypothetical element beyond the bounds of this array. This is due to less or equal sign in the

0 ≤ i + j ≤ n

expression.

Literally, reinterpret_cast<char*> (&obj) + sizeof(Object) is fine because it points to hypothetical element a[j], where j = sizeof(Object) and it is less or equal than size of the array, which is sizeof(Object).

So, the answer is yes.

Otherwise std::end for arrays would be UB.