Can Aliasing Problems be Avoided with const Variables

Question

My company uses a messaging server which gets a message into a const char* and then casts it to the message type.

I\'ve become concerned about this afte

Answer 1

First of all, casting pointers does not cause any aliasing violations (although it might cause alignment violations).

Aliasing refers to the process of reading or writing an object through a glvalue of different type than the object.

If an object has type T, and we read/write it via a X& and a Y& then the questions are:

• Can X alias T?
• Can Y alias T?

It does not directly matter whether X can alias Y or vice versa, as you seem to focus on in your question. But, the compiler can infer if X and Y are completely incompatible that there is no such type T that can be aliased by both X and Y, therefore it can assume that the two references refer to different objects.

So, to answer your question, it all hinges on what PopMessage does. If the code is something like:

const char *PopMessage()
{
     static MessageJ foo = .....;
     return reinterpret_cast(&foo);
}

then it is fine to write:

const char *ptr = PopMessage();
auto bar = reinterpret_cast(foo);

auto baz = *bar;    // OK, accessing a `MessageJ` via glvalue of type `MessageJ`
auto ch = ptr[4];   // OK, accessing a `MessageJ` via glvalue of type `char`

and so on. The const has nothing to do with it. In fact if you did not use const here (or you cast it away) then you could also write through bar and ptr with no problem.

On the other hand, if PopMessage was something like:

const char *PopMessage()
{
    static char buf[200];
    return buf;
}

then the line auto baz = *bar; would cause UB because char cannot be aliased by MessageJ. Note that you can use placement-new to change the dynamic type of an object (in that case, char buf[200] is said to have stopped existing, and the new object created by placement-new exists and its type is T).