Reinterpret_cast vs. C-style cast

by

The C-style cast isn’t better.

It simply tries the various C++-style casts in order, until it finds one that works. That means that when it acts like a reinterpret_cast, it has the exact same problems as a reinterpret_cast. But in addition, it has these problems:

  • It can do many different things, and it’s not always clear from reading the code which type of cast will be invoked (it might behave like a reinterpret_cast, a const_cast or a static_cast, and those do very different things)
  • Consequently, changing the surrounding code might change the behaviour of the cast
  • It’s hard to find when reading or searching the code – reinterpret_cast is easy to find, which is good, because casts are ugly and should be paid attention to when used. Conversely, a C-style cast (as in (int)42.0) is much harder to find reliably by searching

To answer the other part of your question, yes, reinterpret_cast is implementation-defined. This means that when you use it to convert from, say, an int* to a float*, then you have no guarantee that the resulting pointer will point to the same address. That part is implementation-defined. But if you take the resulting float* and reinterpret_cast it back into an int*, then you will get the original pointer. That part is guaranteed.

But again, remember that this is true whether you use reinterpret_cast or a C-style cast:

int i;
int* p0 = &i;

float* p1 = (float*)p0; // implementation-defined result
float* p2 = reinterpret_cast<float*>(p0); // implementation-defined result

int* p3 = (int*)p1; // guaranteed that p3 == p0
int* p4 = (int*)p2; // guaranteed that p4 == p0
int* p5 = reinterpret_cast<int*>(p1); // guaranteed that p5 == p0
int* p6 = reinterpret_cast<int*>(p2); // guaranteed that p6 == p0

More Related Contents:

  1. Can I use the result of a comparison as an integer in C++?
  2. Regular cast vs. static_cast vs. dynamic_cast [duplicate]
  3. Implicit type conversion rules in C++ operators
  4. Multi-character constant warnings
  5. What is the difference between static_cast and C style casting?
  6. Is it safe to delete a void pointer?
  7. C++ cast syntax styles
  8. What does casting to `void` really do? [duplicate]
  9. dynamic_cast and static_cast in C++
  10. Can I assume (bool)true == (int)1 for any C++ compiler?
  11. Converting a pointer into an integer
  12. What exactly is a type cast in C/C++?
  13. C++ convert from 1 char to string?
  14. Should I worry about the alignment during pointer casting?
  15. Cast pointer to member function to normal pointer
  16. C++ auto vs auto&
  17. Can I cast a derived class to a private base class, using C-style cast?
  18. Passing shared_ptr as shared_ptr
  19. Why is “operator void” not invoked with cast syntax?
  20. Why cast a pointer to a float into a pointer to a long, then dereference?
  21. Is reinterpret_cast type punning actually undefined behavior?
  22. Why doesn’t this reinterpret_cast compile?
  23. Is it OK to use C-style cast for built-in types?
  24. Is casting std::pair const& to std::pair const& safe?
  25. Understanding gsl::narrow implementation
  26. Should I use a C++ reinterpret_cast over a C-style cast?
  27. What is the modern, correct way to do type punning in C++?
  28. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?
  29. How to cast simple pointer to a multidimensional-array of fixed size?
  30. How can I extend a lexical cast to support enumerated types?

Leave a Comment