Arithmetic of pointers to non-massive types

Question

Consider the following code snippet:

struct Blob { double x, y, z; } blob; char* s = reinterpret_cast<char*>(&blob); s[2] = 'A'; 

Assuming sizeof (double) is 8, does this code trigger undefined behavior?

Answer 1

Quote from N4140 (approximately C ++ 14):

3.9 Types [basic.types]

2 For any object (except a subobject of the base class) of a trivially copied type T , regardless of whether the object has a valid value of type T , the basic bytes (1.7) that make up the object can be copied to an array from char or unsigned char . ⁴² If the contents of a char or unsigned char array are copied back to the object, the object subsequently saves its original value.

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

3 For any trivially copied type T , if two pointers to T point to different T objects obj1 and obj2 , where neither obj1 nor obj2 is a subobject of the base class, if the base bytes (1.7) that make up obj1 in obj2 , ⁴³ obj2 subsequently it will have the same meaning as obj1 . [Example:...]

43) Using, for example, the library functions (17.6.1.2) std::memcpy or std::memmove .

This allows you, in principle, to allow the assignment directly to s[2] if you are in a position for which the indirect assignment of s[2] should be equivalent to copying all the other Blob to an array, which simply turns out to be identical by default, except for the third byte, and copying it into your Blob : you don't assign s[0] , s[1] , etc. For trivially copied types, including char , this is equivalent to setting them to the exact value that they already have, which also has no observable effect.

However, if the only way to get s[2] == 'A' is with memory manipulation, then there may also be a valid argument that what you copy back to your Blob is not the base bytes that made up any previous Blob . In this case, technically the behavior will be undefined inaction.

I strongly suspect, especially considering "does the object have a valid value of type T " a comment that it was supposed to allow.

Answer 2

Chapter 3.10 of the standard seems to allow for this particular case, suggesting that “access to a stored value” means “read or write,” which is unclear.

3.10-10

If a program tries to access the stored value of an object through a glvalue other than one of the following types, undeformed behavior is defined

- (10.1) the dynamic type of the object,

- (10.2) cv-qualified version of the dynamic type of an object,

- (10.3) a type similar to (as defined in 4.4) for a dynamic type of object,

- (10.4) a type that is a signed or unsigned type corresponding to a dynamic type of an object,

- (10.5) a type that is a signed or unsigned type corresponding to a cv-qualified version of an object's dynamic type,

- (10.6) an aggregate or union type that includes one of the above types among its members or non-static data members (including a recursive member or non-static subaggregate or contains union member),

- (10.7) a type that is (possibly cv-qualified) a base class of the type dynamic object type,

- (10.8) a char or unsigned char type .