Pointer arithmetic within a struct

Question

Within an array, pointer arithmetic is allowed (as long as the result doesn't exceed the bounds, where the end bound is one past the end of the array).

// Legit
int m[3] = {0, 1, 2};
int const *p = m;
std::cout << *p << *(p + 1) << *(p + 2) << std::endl;

Does the standard allow pointer arithmetic like this with a standard layout struct that contains consecutive member variables of the same fundamental type?

// Well defined???
struct MyStruct {
    int a, b, c;
};
static_assert(std::is_standard_layout_v<MyStruct>);

MyStruct  m = {0, 1, 2};
int const *p = &m.a;
std::cout << *p << *(p + 1) << *(p + 2) << std::endl;

I certainly can compare pointers to the individual variables (i.e., &m.a < &m.b) because they are members of the same object, but I cannot determine whether &m.a+1 is guaranteed to be &m.b.

I know this will likely work with most compilers, but I'm curious about what the standard says (C++20, if it matters).

Answer 1

From section Additive operators

(Emphasis mine)

When an expression J that has integral type is added to or subtracted from an expression P of pointer type, the result has the type of P.

• If P evaluates to a null pointer value and J evaluates to 0, the result is a null pointer value.
• Otherwise, if P points to an array element 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) array element i + j [...]
• Otherwise, the behavior is undefined.

Bottom line, no guarantees if the underlying type is not an array.

To your point, std::is_standard_layout_v provides guarantees regarding the layout itself, which can include guarantees for arrays contained in it, but it does not qualify the struct itself to be an array of elements, which the standard expects to use pointer arithmetics.