Выводит указатель на разные структуры, которые могут быть значимыми в C89?

Question

Я два Структуры, как

struct X { 
    int x; 
    double *y; 
}; 

struct Y { 
    int a; 
    double *b; 
    char c; 
}; 

бросает указатель struct Y на указатель на struct X гарантированно вести себя последовательно в разумных пределах (т.е. x->x и x->y соответствуют y->a и y->b соответственно) по стандарту C89? Менее важно, но было бы здорово, если бы вы также узнали, что это справедливо и для более поздних стандартов (например, C11) и других языков, которые имеют существенное синтаксическое и семантическое совпадение с C (например, C++ XX, Objective-C)?

Answer 1

Это неопределенное поведение. Python relied on this before and had to fix that. Если struct Y включают struct X в качестве первого элемента, вы можете использовать это для подобного эффекта:

struct Y { 
    struct X a; 
    char c; 
}; 

struct Y y; 
struct X *x = (struct X *) &y; /* legal! */ 

Там также особый случай для профсоюзов:

struct X { 
    int x; 
    double *y; 
}; 

struct Y { 
    int a; 
    double *b; 
    char c; 
}; 

union XY { 
    struct X x; 
    struct Y y; 
}; 

union XY xy; 
xy.x.x = 0; 
printf("%d\n", xy.y.a); /* legal! */ 

В более поздних версиях стандарта C , компилятор должен обрабатывать только X и Y объекты, псевдонизирующие друг друга, если такое определение объединения действительно в области видимости, но на C89 оно в основном должно предполагать, что такое определение существует где-то. Тем не менее, это не мешает лить struct Y * на struct X *; если компилятор знает, что конкретный struct Y не является частью союза, он все равно может предположить, что struct X * не может его псевдонимом.

Answer 2

C89 разрешает преобразование путем литья указателя на один тип объекта указателю на другой тип объекта.

Прежде, чем мы даже разойдемся с разыменованием, преобразованный указатель гарантированно будет действительным вообще, только если ссылочный тип исходного указателя требует выравнивания по меньшей мере так же строго, как и тип, на который ссылается указатель результата. Выравнивание полностью зависит от реализации. В вашем конкретном примере, вероятно, , но не гарантируется, что два типа struct будут иметь одинаковое требование выравнивания.

Предполагая, что преобразование действительно приводит к действительному указателю, стандарт не определяет точно, как элементы struct выложены внутри представления объекта struct. Члены должны отображаться в том же порядке, что и в определении struct, и не должно быть никаких отступов до первого, но никакие другие детали не определены. В вашем примере, следовательно, гарантируется, что X->x будет соответствовать Y->a (предположим, что преобразованный указатель действительно в первую очередь), но не определено, будет ли X->y соответствовать Y->b.