Uses of pointer arithmetic within an object

Question

Excerpt from the book "C++ memory management" by Patrice Roy

For example, the following code is correct, albeit not something one should seek to do (it makes no sense, and it does things in unnecessarily complicated ways, but it’s legal and does no harm):

struct A {
   int a;
   short s;
};

short * f(A &a) {
    // pointer interconvertibility in action!
    int *p = reinterpret_cast<int*>(&a);
    p++;
    return reinterpret_cast<short*>(p); // Ok, within the
                                       // same object
}

int main() {
    A a;
    short *p = f(a);
    *p = 3; // fine, technically
}

Author does not elaborate this statement. Is it correct from standard point of view and under what condition if so ?

Why use &a in the reinterpret_cast, when a is already a pointer? Should it be reinterpret_cast<int *>(a)? — Thomas Matthews
– Thomas Matthews, Commented May 30 at 22:02
The code is not legal. There can be padding between a and s so at best it's implementation defined. — NathanOliver
– NathanOliver, Commented May 30 at 22:09
It's not !00% kosher, but what Roy seems to be getting at is C++ doesn't really care what address a pointer points at so long as the type of the object at that pointer matches the type you say it is. Here Roy took a pointer to an int advanced the address by one int where, baring unusual behaviour, a short sits. Since the pointed-at object is a short and will, thanks to the reinterpret_cast be used as a short it's all good. Unfortunately C++ doesn't guarantee that s will be immediately after a in memory. For example, how would a 24-bit short be aligned after a 32 bit int? — user4581301
– user4581301, Commented May 30 at 22:41
This code would only work if the short existed immediately behind the int in memory (ie, no padding existed), but this code does not guarantee that. The proper way to get a valid pointer to the short using pointer arithmetic would be something like this instead: char *p = reinterpret_cast<char*>(&a); p += offsetof(A, s); return reinterpret_cast<short*>(p); — Remy Lebeau
– Remy Lebeau, Commented May 31 at 0:29

Jeff Garrett · Accepted Answer · 2025-05-31 20:42:47Z

1

I believe this is incorrect. Assuming for argument's sake that size and alignment and padding work out, which aren't checked, there is still a violation of pointer rules.

reinterpret_cast between A* and int* works by the rules of pointer interconvertibility, and given a pointer to an A object, one can obtain a pointer to the int object which is its first member.

So p is a valid pointer to an object basic.compound

By expr.add, ++p results in a pointer "past the end" of the int member. Therefore, it represents the "first byte in memory after the end of the storage occupied by the object" but it does not point at the short. With the assumption that the address is the address of the short, we can try to get a pointer through std::launder. ptr.launder

std::launder(reinterpret_cast<short*>(p))

But this requires that all bytes reachable through the result are reachable through the initial pointer, which is not the case. basic.compound

Therefore, the example is illegal.

edited May 31 at 20:42

answered May 31 at 0:38

Jeff Garrett

8,4791 gold badge22 silver badges19 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Language Lawyer May 31 at 20:08

launder reachability requirement is not satisfied

Jeff Garrett May 31 at 20:43

Oh my, good catch. Check the edit.

Collectives™ on Stack Overflow

Uses of pointer arithmetic within an object

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related