reinterpret_cast between char* and std::uint8_t* – safe?

by

Ok, let’s get truly pedantic. After reading this, this and this, I’m pretty confident that I understand the intention behind both Standards.

So, doing reinterpret_cast from std::uint8_t* to char* and then dereferencing the resulting pointer is safe and portable and is explicitly permitted by [basic.lval].

However, doing reinterpret_cast from char* to std::uint8_t* and then dereferencing the resulting pointer is a violation of strict aliasing rule and is undefined behavior if std::uint8_t is implemented as extended unsigned integer type.

However, there are two possible workarounds, first:

static_assert(std::is_same_v<std::uint8_t, char> ||
    std::is_same_v<std::uint8_t, unsigned char>,
    "This library requires std::uint8_t to be implemented as char or unsigned char.");

With this assert in place, your code will not compile on platforms on which it would result in undefined behavior otherwise.

Second:

std::memcpy(uint8buffer, charbuffer, size);

Cppreference says that std::memcpy accesses objects as arrays of unsigned char so it is safe and portable.

To reiterate, in order to be able to reinterpret_cast between char* and std::uint8_t* and work with resulting pointers portably and safely in a 100% standard-conforming way, the following conditions must be true:

  • CHAR_BIT == 8.
  • std::uint8_t is defined.
  • std::uint8_t is implemented as char or unsigned char.

On a practical note, the above conditions are true on 99% of platforms and there is likely no platform on which the first 2 conditions are true while the 3rd one is false.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Is the size of std::array defined by standard
  3. Capturing a reference by reference in a C++11 lambda
  4. Is a moved-from vector always empty?
  5. c++ access static members using null pointer
  6. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  7. Why is modifying a string through a retrieved pointer to its data not allowed?
  8. Get pointer to object from pointer to some member
  9. Is it legal to declare a constexpr initializer_list object?
  10. Are notes and examples in the core language specification of the C++ Standard non-normative?
  11. What does the void() in decltype(void()) mean exactly?
  12. Can the point-of-instantiation be delayed until the end of the translation unit?
  13. Can C++ code be valid in both C++03 and C++11 but do different things?
  14. What is the value category of the operands of C++ operators when unspecified?
  15. How can an incomplete type be used as a template parameter to vector here?
  16. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  17. Is left-shifting (
  18. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  19. Classes with both template and non-template conversion operators in the condition of switch statement
  20. Does C++11 allow dollar signs in identifiers?
  21. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  22. What expressions create xvalues?
  23. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  24. Calling an explicit constructor with a braced-init list: ambiguous or not?
  25. Can we apply content not explicitly cited from the normative references to the C++ standard?
  26. Calling delete on NULL pointers – C++03 vs C++11
  27. std::tuple memory alignment
  28. Rvalues, lvalues and formal definitions
  29. What is use of the ref-qualifier `const &&`?
  30. Can using a lambda in header files violate the ODR?

Leave a Comment