Strict aliasing violation and memory address

Question

I'm trying to understand strict aliasing rule for C and C++. I've asked lots of questions about this and done a bit of reading on it but I just want to clarify something.

// void* can alias any other type:
int anInt;
void* pToVoid = (void*)&anInt; // Allowed
// So can char*
char* pToChar = (char*)&anInt; // Allowed

Pointer to any type can alias void*, that's why we can do something like:

int* myNewInt = (int*)malloc(sizeof(int));

But:

(Question 1) Can any pointer type alias char pointer?

    char myChars[4];
    int* pInt = (int*)myChars; // Is this allowed?
// I'm guessing so because this is how we create buffers
    float* pFloat = (float*) pInt; // I know this is strict aliasing violation

Question 2: Also when aliasing any pointer type to a char or void pointer type we need ensure correct alignment, right? There's no guarantee on the stack that a char or char array will be aligned as we get it from new or malloc, right?

My third question is if the strict aliasing rule is violated when you cast a pointer or when a pointer aliases the same memory? For example:

struct MyStruct
{
    int myInt;
    float myFloat;
};

int main()
{
    MyStruct myStructObj;
    float* pFloat = &myStructObj.myInt; // This is aliasing the wrong type, not allowed
// However if I move the float* then it no longer aliases the wrong type
    pFloat += 1;
// Now the pointer points to the right type. However is it now too late? My program
// has UB because I first aliased the pointer in the first place?
// On the other hand I assume this is allowed though:
   float pFloat = (float*)(((char*)&myStructObj.myInt) + sizeof(int));
// This way the float pointer never aliases the int, the int pointer is 
// first cast to char*, then char* to float*, which I assume is allowed.
}

In other words is the strict aliasing rule about accessing the same memory or assigning different pointer types? Because if it's only about memory access then my example of assigning the float* to the int* is fine because I move it first, right?

Edit: It's been pointed out that the aliasing rules are different for C and C++, therefore I've tagged this to be about C++.

Answer 1

Strict alias violation is about accessing data via an incompatible handle. In your code, you never access the data. Converting pointers is just converting the value of pointers, it has nothing really to do with alias violations.

void* can alias any other type:

Yes, you can convert any other pointer value to a pointer of type void *.

Can any pointer type alias char pointer?

A pointer has to point to a memory location aligned to the type it's pointing to. Let's say C11 6.3.2.3p7 and C++draft expr#static.cast-13 and C++draft expr#reinterpret.cast-7. When the pointer is not aligned, I see the result is undefined in C and unspecified in C++.

float* pFloat = (float*) pInt; // I know this is strict aliasing violation

No, it is not, you do not access the data behind the pointer. Assuming the pointer is properly aligned (it may be not) and sizeof(float) == sizeof(myChars) (it may be not): now, if you would do for example *pFloat = 1.0;, then you would actually access the data, and then you could possibly finally have anything to do with alias violation. I think Is using the result of new char[] or malloc to casted float * is UB (strict aliasing violation)? nicely answers all cases.

There's no guarantee on the stack that a char or char array will be aligned as we get it from new or malloc, right?

Yes.

is if the strict aliasing rule is violated when you cast a pointer or when a pointer aliases the same memory?

No, casting a pointer does not access the data. No, two pointers pointing to the same location does not access the data behind pointers.

is the strict aliasing rule about accessing the same memory or assigning different pointer types?

Only about accessing.

Because if it's only about memory access then my example of assigning the float* to the int* is fine because I move it first, right?

Because of that, there are different rules that affect it. There is no guarantee that MyStruct::myFloat is at sizeof(int) from the start - compiler can insert padding between structure members. Use offsetof macro.

Answer 2

The problem:
In C++ aliasing is all about register usage. It is not uncommon for floating point values to held in registers which are different to those used for integers. In effect, when the compiler caches a value it must bind it to a register. If you load the same value as different types, you can end up with more than one register being bound to the same value (say, one register with the int value and one register with a float version).
One way to solve this issue is to tell the compiler to always write to memory (disabling some register caching - making the code slower)
The other is to promise the compiler it can cache any way it sees fit, and you will never change the type.

Utilities
The modern solution is (spans) A library was made to support this solution on older compilers gsl::span. Both solutions support "as_bytes" functions.

The modern way of safely manipulating such problems is to model your memory as std::bytes (gsl::bytes in older code). As this answer says Has a std::byte pointer the same aliasing implications as char*?, the standard specifies std::byte is never prone to aliasing issues. This solution does force you to copy explicitly, which is probably by design.

Update:
Your Questions:

1. Yes, any pointer to char avoids aliasing issues (but prefer byte)
2. If you create your objects as their own types, and generate byte-spans, then alignment is never an issue. Bytes do not have alignment.
3. Aliasing is violated whenever you deference a pointer to the same memory, as different types. As stated above, this risks creating two cached values, which may then become out-of-sync.

Update: Just discovered https://en.cppreference.com/w/cpp/numeric/bit_cast. Cool

Additional
Sorry, I just realised I missed something from your question. Casting an arbitrary pointer to char, to a basic type (like int) is not guaranteed to work. This is nothing to do with aliasing though. It is to do with the CPU. It will work on x86/x64, because the CPU supports this. Not all CPU's do. It is always valid to copy from a char/byte pointer, though.