strict-aliasing

I'm reading notes about reinterpret_cast and it's aliasing rules ( http://en.cppreference.com/w/cpp/language/reinterpret_cast ). I wrote that code: struct A { int t; }; char *buf = new char[sizeof(A)]; A *ptr = reinterpret_cast<A*>(buf); ptr->t = 1; A *ptr2 = reinterpret_cast<A*>(buf); cout << ptr2->t; I think these rules doesn't apply here: T2 is the (possibly cv-qualified) dynamic type of the object T2 and T1 are both (possibly multi-level, possibly cv-qualified at each level) pointers to the same type T3 (since C++11) T2 is an aggregate type or a union type which holds one of the

See http://pubs.opengroup.org/onlinepubs/009696699/basedefs/sys/socket.h.html ( http://pubs.opengroup.org/onlinepubs/9699919799 is from Issue 7 - from 2013 and still the same!) sockaddr_storage is meant to be cast to other structure types, but that contradicts the ANSI and ISO C standards aliasing rules as far as I can tell. (Objects may not be accessed through pointers to incompatible types, with the exception that anything can be accessed through the 3 char types and that the structure and its first member are interchangeable.) I know that that practice of working with sockets existed long

This question already has an answer here: Does this really break strict-aliasing rules? 2 answers The following example comes from std::aligned_storage page of cppreference.com: #include <iostream> #include <type_traits> #include <string> template<class T, std::size_t N> class static_vector { // properly aligned uninitialized storage for N T's typename std::aligned_storage<sizeof(T), alignof(T)>::type data[N]; std::size_t m_size = 0; public: // Create an object in aligned storage template<typename ...Args> void emplace_back(Args&&... args) { if( m_size >= N ) // possible error handling throw

If anybody answers my question, please don't tell me to use C++ . So, I'm making a small library in C that uses an object-oriented approach. I chose to use the less-common of the two main approaches to inheritance in C: copying the members of the base type to the beginning of the derived type. Something like this: struct base { int a; int b; char c; }; struct derived { int a; int b; char c; unsigned int d; void (*virtual_method)(int, char); }; This approach is less popular than the other one (an instance of the base type as the first member of the derived type) because technically, there is no

I recently was surprised to learn that the C and C++ language standards have a "strict aliasing" rule. In essence, the rule prohibits variables of differing types from referencing the same memory location. As an example: char buffer[4] = { 0x55, 0x66, 0x77, 0x88 }; int32 *p = (int32*)&buffer[0]; // illegal because buffer[0] and *p are different types Most of the professional C++ developers I interact with are not familiar with this rule. Based on my research, it seems to affect mostly GCC/G++/CLANG users. Does Visual C++ support enabling/disabling this rule? If so, how does one do so? Thank

This question already has an answer here: What's a proper way of type-punning a float to an int and vice-versa? 7 answers From what I understood about strict aliasing rule , this code for fast inverse square root will result in undefined behavior in C++: float Q_rsqrt( float number ) { long i; float x2, y; const float threehalfs = 1.5F; x2 = number * 0.5F; y = number; i = * ( long * ) &y; // type punning i = 0x5f3759df - ( i >> 1 ); y = * ( float * ) &i; y = y * ( threehalfs - ( x2 * y * y ) ); return y; } Does this code indeed cause UB? If yes, how can it be reimplemented in standard

The restrict keyword's behavior is defined in C99 by 6.7.3.1: Let D be a declaration of an ordinary identifier that provides a means of designating an object P as a restrict-qualified pointer to type T. If D appears inside a block and does not have storage class extern, let B denote the block. If D appears in the list of parameter declarations of a function definition, let B denote the associated block. Otherwise, let B denote the block of main (or the block of whatever function is called at program startup in a freestanding environment). In what follows, a pointer expression E is said to be