Почему GCC и Clang не занимаются оптимизацией псевдонимов?

Неопределенное поведение включает в себя случай, когда оно делает работать, даже если это не должно.

В соответствии со стандартным использованием это объединение позволяет получить доступ к полям типа и размера заголовка или членов данных:

union Packet {
struct Header {
short type;
short size;
} header;
struct Data {
short type;
short size;
unsigned char data[MAX_DATA_SIZE];
} data;
}

Это строго ограничено объединениями, но многие компиляторы поддерживают это как своего рода расширение, при условии, что «неполный» тип будет заканчиваться массивом неопределенного размера. Если вы удаляете лишний статический не член из дочернего класса, он действительно становится тривиальным и совместимым с макетом, что позволяет создавать псевдонимы?

struct A {
int a;
};

struct B  {
int a;
//int x;
};

A a;

int g(B *b) {
a.a = 10;
b->a++;
return a.a;
}

Тем не менее, по-прежнему выполняет оптимизацию псевдонимов. В вашем случае с таким же количеством нестатических членов предполагается, что наиболее производный класс совпадает с базовым классом. Давайте изменим порядок:

#include <vector>
#include <iostream>

struct A {
int a;
};

struct B : A  {
int x;
};

B a;

int g(A *b) {
a.a = 10;
b->a++;
return a.a;
}

int main()
{
std::cout << g((A*)&a);
}

Это возвращает 11, как и ожидалось, поскольку B явно также является A, в отличие от первоначальной попытки. Давай играть дальше

struct A {
int a;
};

struct B : A {
int  foo() { return a;}
};

Не приведет к оптимизации псевдонимов, если foo () не является виртуальным. Добавление нестатического или константного члена к B приведет к ответу «10», добавление нетривиального конструктора или статического нет.

PS.
Во втором примере

enum A : int { X, Y };
enum B : int { Z };

Совместимость макетов между этими двумя здесь определяется C ++ 14, и они не совместимы с базовым типом (но конвертируемы). хотя что то типа

 enum A a = Y;
enum B b = (B*)a;

может привести к неопределенному поведению, как если бы вы пытались отобразить float с произвольным 32-битным значением.

Я думаю, что ваш код UB, так как вы разыменовываете указатель, полученный из преобразования, нарушающего правила наложения типов.

Теперь, если вы активируете флаг строгого алиасинга, вы позволяете компилятору оптимизировать код для UB. Как использовать этот UB зависит от компилятора. Вы можете увидеть ответы на этот вопрос.

Что касается GCC, то документация для -fstrict-aliasing показывает, что он может оптимизировать на основе:

(…) предполагается, что объект одного типа никогда не будет находиться в одном месте
адрес как объект другого типа, если типы не являются почти
тот же самый.

Мне не удалось найти определение для «почти одинакового», но два класса с абсолютно одинаковым макетом можно считать «почти одинаковыми», и они не включены в оптимизацию.

Я считаю, что следующее допустимо в C ++ (без вызова UB):

#include <new>

struct A {
int a;
};

struct B : A {
// int x;
};

static A a;

int g(B *b);
int g(B *b) {
a.a = 10;
b->a++;
return a.a;
}

int f();
int f() {
auto p = new (&a) B{};
return g(p);
}

потому что (глобальный) a всегда относится к объекту типа A (хотя это подобъект B-объект после звонка f()) а также p указывает на объект типа B,

Если вы отметите a иметь static длительность хранения (как я делал выше), все протестированные мной компиляторы с радостью применят строгое псевдонимы и оптимизируют для возврата 10,

С другой стороны, если вы отметите g() с __attribute__((noinline)) или добавить функцию h() который возвращает указатель на a

A* h();
A* h() { return &a; }

компиляторы, которые я тестировал, предполагают, что &a и параметр b может псевдоним и перезагрузить значение.