Is it a strict aliasing violation to alias a struct as its first member?

by

The behaviour of the cast comes down to [expr.static.cast]/13;

A prvalue of type “pointer to cv1 void” can be converted to a prvalue of type “pointer to cv2 T”, where T is an object type and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1. If the original
pointer value represents the address A of a byte in memory and A does not satisfy the alignment requirement of T , then the resulting pointer value is unspecified. Otherwise, if the original pointer value points to an object a, and there is an object b of type T (ignoring cv-qualification) that is pointer-interconvertible with a, the result is a pointer to b. Otherwise, the pointer value is unchanged by the conversion.

The definition of pointer-interconvertible is:

Two objects a and b are pointer-interconvertible if:

  • they are the same object, or
  • one is a union object and the other is a non-static data member of that object, or
  • one is a standard-layout class object and the other is the first non-static data member of that object, or, if the object has no non-static data members, the first base class subobject of that object, or
  • there exists an object c such that a and c are pointer-interconvertible, and c and b are pointer-interconvertible.

So in the original code, s and s.x are pointer-interconvertible and it follows that (int &)s actually designates s.x.

So, in the strict aliasing rule, the object whose stored value is being accessed is s.x and not s and so there is no problem, the code is correct.

More Related Contents:

  1. Is there a (semantic) difference between the return value of placement new and the casted value of its operand?
  2. Does accessing the first field of a struct via a C cast violate strict aliasing?
  3. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  4. Does this really break strict-aliasing rules?
  5. casting via void* instead of using reinterpret_cast [duplicate]
  6. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  7. Is reinterpret_cast type punning actually undefined behavior?
  8. reinterpret_cast between char* and std::uint8_t* – safe?
  9. Should I use static_cast or reinterpret_cast when casting a void* to whatever
  10. Will std::string always be null-terminated in C++11?
  11. Is passing a C++ object into its own constructor legal?
  12. std::ignore with structured bindings?
  13. Why is it not possible to overload class templates?
  14. treating memory returned by operator new(sizeof(T) * N) as an array
  15. Is circumventing a class’ constructor legal or does it result in undefined behaviour?
  16. Why is f(i = -1, i = -1) undefined behavior?
  17. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  18. Why does `int ;` compile fine in C, but not in C++?
  19. Can I Reference Previous Members of an Initializer List?
  20. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  21. Why doesn’t an if constexpr make this core constant expression error disappear?
  22. Why doesn’t this reinterpret_cast compile?
  23. Use of typename keyword with typedef and new
  24. Lifetime of object is over before destructor is called?
  25. reinterpret_cast from object to first member
  26. Are pointers to non-static member function “formally” not considered pointers
  27. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  28. Why is `make_unique` disallowed?
  29. Will I be able to declare a constexpr lambda inside a template parameter?
  30. Is it safe to reinterpret_cast an enum class variable to a reference of the underlying type?

Leave a Comment