strict-aliasing

This is a follow up to this other question about memory re-use. As the original question was about a specific implementation, the answer was related to that specific implementation. So I wonder whether, it is legal in a conformant implementation to re-use the memory of an array of a fundamental type for an array of a different type provided: both types are fundamental type and as such have trivial dtor and default ctor both types have same size and alignment requirement I ended with the following example code: #include <iostream> constexpr int Size = 10; void *allocate_buffer() { void * buffer

I've got some code that uses type-punning to avoid having to call a member "object"'s constructor and destructor unless/until it's actually necessary to use the object. It works fine, but under g++ 4.4.3, I get this dreaded compiler warning: jaf@jeremy-desktop:~$ g++ -O3 -Wall puns.cpp puns.cpp: In instantiation of ‘Lightweight<Heavyweight>’: puns.cpp:68: instantiated from here puns.cpp:12: warning: ignoring attributes applied to ‘Heavyweight’ after definition puns.cpp: In destructor ‘Lightweight<T>::~Lightweight() [with T = Heavyweight]’: puns.cpp:68: instantiated from here puns.cpp:20:

Suppose I have a chunk of dynamically allocated data: void* allocate (size_t n) { void* foo = malloc(n); ... return foo; } I wish to use the data pointed at by foo as a special type, type_t . But I want to do this later, and not during allocation. In order to give the allocated data an effective type , I can therefore do something like: void* allocate (size_t n) { void* foo = malloc(n); (void) *(type_t*)foo; ... return foo } As per C11 6.5/6, this lvalue access should make the effective type type_t : For all other accesses to an object having no declared type, the effective type of the object

For example, is this code valid, or does it invoke undefined behavior by violating the aliasing rules? int x; struct s { int i; } y; x = 1; y = *(struct s *)&x; printf("%d\n", y.i); My interest is in using a technique based on this to develop a portable method for performing aliased reads. Update: here is the intended usage case, a little bit different, but it should be valid if and only if the above is valid: static inline uint32_t read32(const unsigned char *p) { struct a { char r[4]; }; union b { struct a r; uint32_t x; } tmp; tmp.r = *(struct a *)p; return tmp.x; } GCC, as desired,

Let's say, I have an array of unsigned chars that represents a bunch of POD objects (e.g. either read from a socket or via mmap). Which types they represent and at what position is determined at runtime, but we assume, that each is already properly aligned. What is the best way to "cast" those bytes into the respective POD type? A solution should either be compliant to the c++ standard (let's say >= c++11) or at least be guaranteed to work with g++ >= 4.9, clang++ >= 3.5 and MSVC >= 2015U3. EDIT: On linux, windows, running on x86/x64 or 32/64-Bit arm. Ideally I'd like to do something like this