Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?

by

why doesn’t reinterpret_cast handle that for me?

One reason is that the size, alignment, and bit representations aren’t specified, so such a conversion wouldn’t be portable. However, that wouldn’t really justify making the behaviour undefined, just implementation-defined.

By making it undefined, the compiler is allowed to assume that expressions of unrelated types don’t access the same object, which can allow better optimisation. For example, in the following:

int   & i = something();
float & f = something_else();

const int i1 = i;
f = 42;
const int i2 = i;

the compiler can assume that i1 and i2 both have the same value (i being unchanged by the assignment to f), and optimise them into a single constant. Breaking the assumption will then cause undefined behaviour.

Or is there something else available so I don’t have to jump through this hoop?

Copying the bytes is the only well-defined way to reinterpret one object type as an unrelated type.

Aliasing with reinterpret_cast or a union might work sometimes (assuming the size etc. match), but might trip you up if the optimiser gets too clever with undefined behaviour.

More Related Contents:

  1. When to use reinterpret_cast?
  2. Why unsigned int 0xFFFFFFFF is equal to int -1?
  3. casting via void* instead of using reinterpret_cast [duplicate]
  4. Is reinterpret_cast type punning actually undefined behavior?
  5. Why doesn’t this reinterpret_cast compile?
  6. Is casting std::pair const& to std::pair const& safe?
  7. Should I use a C++ reinterpret_cast over a C-style cast?
  8. C++ When should we prefer to use a two chained static_cast over reinterpret_cast
  9. Why do we have reinterpret_cast in C++ when two chained static_cast can do its job?
  10. Is const_cast safe?
  11. What is the difference between static_cast and C style casting?
  12. Is it safe to use -1 to set all bits to true?
  13. Is it safe to delete a void pointer?
  14. C++ cast syntax styles
  15. How do I avoid implicit conversions on non-constructing functions?
  16. C++ convert from 1 char to string?
  17. Function pointers casting in C++
  18. How to reverse an std::string? [duplicate]
  19. Is there a (semantic) difference between the return value of placement new and the casted value of its operand?
  20. Avoiding copy of objects with the “return” statement
  21. Can I cast a derived class to a private base class, using C-style cast?
  22. How to do serialization of Class having members of custom data types in C++? [closed]
  23. Is it OK to use C-style cast for built-in types?
  24. Does reinterpret_cast lead to undefined behavior?
  25. Understanding gsl::narrow implementation
  26. Is it a strict aliasing violation to alias a struct as its first member?
  27. How can I copy one map into another using std::copy?
  28. Why is reinterpret_cast not constexpr?
  29. What is the modern, correct way to do type punning in C++?
  30. Is it safe to reinterpret_cast an enum class variable to a reference of the underlying type?

Leave a Comment