strict-aliasing

I recently asked this question: Using this pointer causes strange deoptimization in hot loop The problem was that I was writing to an array of type uint8_t and the compiler treated it as if it could alias with the this pointer of the method (of type struct T* ), because void* and char* (= uint8_t* ) can always alias any other pointer in C++. This behaviour caused a missed optimization opportunity. I want to avoid this, of course. So the question is: Can I declare an uint8_t array that enforces strict aliasing, i.e., that the compiler treats as never aliased with any pointer of another type? I

I've been reading up on the strict aliasing rules over the last week or so and ran into this article: Understanding C/C++ Strict Aliasing . The article goes through several ways two swap the halves of a 32-bit integer, giving both good examples and ones that violate the strict aliasing rule. I'm having trouble understanding one of the examples, though. This code is described as broken. uint32_t swaphalves(uint32_t a) { a = (a >> 16) | (a << 16); return a; } The reason given is: This version looks reasonable, but you don't know if the right and left sides of the | will each get the original

To overcome alignment issues, I need to memcpy into a temporary. What type should that temporary be? gcc complains that the following reinterpret_cast will break strict aliasing rules: template <typename T> T deserialize(char *ptr) { static_assert(std::is_trivially_copyable<T>::value, "must be trivially copyable"); alignas(T) char raw[sizeof(T)]; memcpy(raw, ptr, sizeof(T)); return *reinterpret_cast<T *>(raw); } (e.g. when T is "long"). I don't want to define a T, since I don't want to construct a T before overwriting it. In a union, doesn't writing one member then reading another count as

3.10/10 says: If a program attempts to access the stored value of an object through a glvalue of other than one of the following types the behavior is undefined: However, the term "access" is not defined anywhere. In this context does it mean read , or read or modify ? In the C standard it is unambiguously defined as read or modify . However in C++11 it seems to be used with different meanings at different times, for example: 1.9/8: Access to volatile objects are evaluated strictly according to the rules of the abstract machine. Clearly this is meant to be read or modify , however in many other

This is such a simple pattern, there has to be a "nice" way of sorting it out. I have a function that needs to generate a dynamically sized byte array containing arithmetic data. // Given that I have a function that kinda looks like this: void dispatch(std::vector<char> data); //Will take possesion of data. // The behavior I want, but this breaks strict aliasing void bad_foo(int c) { std::vector<char> real_data(c * sizeof(float)); float* raw_data = reinterpret_cast<float*>(real_data.data()); //Fill raw_data with usefull stuff... dispatch(std::move(real_data)); } void correct_but_slow_foo(int c