- A+

Consider the following code:

`int* p1 = new int[100]; int* p2 = new int[100]; const ptrdiff_t ptrDiff = p1 - p2; int* p1_42 = &(p1[42]); int* p2_42 = p1_42 + ptrDiff; `

Now, does the Standard guarantee that `p2_42`

points to `p2[42]`

? If not, is it always true on Windows, Linux or webassembly heap?

To add the standard quote:

When two pointer expressions

`P`

and`Q`

are subtracted, the type of the result is an implementation-defined signed integral type; this type shall be the same type that is defined as`std::ptrdiff_t`

in the`<cstddef>`

header ([support.types]).

(5.1) If

`P`

and`Q`

both evaluate to null pointer values, the result is 0.(5.2) Otherwise, if

`P`

and`Q`

point to, respectively, elements`x[i]`

and`x[j]`

of the same array object`x`

, the expression`P - Q`

has the value`i−j`

.(5.3) Otherwise, the behavior is undefined. [

Note:If the value`i−j`

is not in the range of representable values of type`std::ptrdiff_t`

, the behavior is undefined. — end note ]

(5.1) does not apply as the pointers are not nullptrs. (5.2) does not apply because the pointers are not into the same array. So, we are left with (5.3) - UB.