Is adding to a “char *” pointer UB, when it doesn’t actually point to a char array?

by

The addition is intended to be valid, but I do not believe the standard manages to say so clearly enough. Quoting N4140 (roughly C++14):

3.9 Types [basic.types]

2 For any object (other than a base-class subobject) of trivially copyable type T, whether or not the object holds a valid value of type T, the underlying bytes (1.7) making up the object can be copied into an array
of char or unsigned char.42 […]

42) By using, for example, the library functions (17.6.1.2) std::memcpy or std::memmove.

It says “for example” because std::memcpy and std::memmove are not the only ways in which the underlying bytes are intended to be allowed to be copied. A simple for loop which copies byte by byte manually is supposed to be valid as well.

In order for that to work, addition has to be defined for pointers to the raw bytes that make up an object, and the way definedness of expressions works, the addition’s definedness cannot depend on whether the addition’s result will subsequently be used to copy the bytes into an array.

Whether that means those bytes form an array already or whether this is a special exception to the general rules for the + operator that is somehow omitted in the operator description, is not clear to me (I suspect the former), but either way would make the addition you’re performing in your code valid.

More Related Contents:

  1. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  2. reinterpret_cast creating a trivially default-constructible object
  3. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  4. When is a private constructor not a private constructor?
  5. When using C headers in C++, should we use functions from std:: or the global namespace?
  6. Is `long` guaranteed to be at least 32 bits?
  7. How is P0522R0 breaking code?
  8. Do I really need to implement user-provided constructor for const objects?
  9. Pure virtual functions may not have an inline definition. Why?
  10. Do all pointers have the same size in C++?
  11. Force all classes to implement / override a ‘pure virtual’ method in multi-level inheritance hierarchy
  12. Can class template constructors have a redundant template parameter list in c++20
  13. Is std::abs(0u) ill-formed?
  14. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  15. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  16. Does accessing the first field of a struct via a C cast violate strict aliasing?
  17. Implementing a std::vector like container without undefined behavior
  18. Is most vexing parse a formally defined concept
  19. Pseudo-destructor call does not destroy an object
  20. Why is a constexpr function on a reference not constexpr?
  21. C++ – Why static member function can’t be created with ‘const’ qualifier
  22. Is a constexpr array necessarily odr-used when subscripted?
  23. Does C have One Definition Rule like C++?
  24. Dangling references and undefined behavior
  25. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  26. Is it a strict aliasing violation to alias a struct as its first member?
  27. What is the modern, correct way to do type punning in C++?
  28. Using std::bind with member function, use object pointer or not for this argument?
  29. Overload resolution with ref-qualifiers
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment