Casting между несвязанными конгруэнтными классами

Question

Пусть у меня есть два класса с одинаковыми членами из двух различных библиотек:

namespace A { 
    struct Point3D { 
    float x,y,z; 
    }; 
} 

namespace B { 
    struct Point3D { 
    float x,y,z; 
    }; 
} 

Когда я пытаюсь кросс-кастинг, он работал:

A::Point3D pa = {3,4,5}; 
B::Point3D* pb = (B::Point3D*)&pa; 
cout << pb->x << " " << pb->y << " " << pb->z << endl; 

При каких обстоятельствах это гарантированно работать? Всегда? Обратите внимание, что было бы крайне нежелательно редактировать внешнюю библиотеку, чтобы добавить прагму выравнивания или что-то в этом роде. Я использую g ++ 4.3.2 на Ubuntu 8.10.

Answer 1

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

Пока они POD, все должно быть в порядке. http://en.wikipedia.org/wiki/Plain_old_data_structures

В соответствии со стандартом (1.8.5)

«Если это не является битовым поле (9.6), наиболее производным объект должен иметь ненулевой размер и должен занимать один или несколько байт . Субобъекты базового класса могут иметь нулевой размер. Объект POD5) тип (3.9) должен занимать смежные байты . "

Если они занимают смежные байт памяти, и они же структура, с другим именем, литая удастся

Answer 2

Я точно знаю, что не будет работать:

• как структура имеет диффере выравнивание;
• скомпилирован с различными вариантами RTTI

может быть какой-то другой ...

Answer 3

Эта линия должна быть:

B::Point3D* pb = (B::Point3D*)&pa; 

Обратите внимание на &. Я думаю, что вы делаете reinterpret_cast между двумя указателями. Фактически вы можете reinterpret_cast любой тип указателя на другой, независимо от типа двух указателей. Но это небезопасно, а не портативно.

Например,

int x = 5; 
double* y = reinterpret_cast<double*>(&x); 

Вы только собираетесь с C-Style, Так что вторая линия фактически равна:

double* z = (double*)&x; 

Я просто ненавижу C-Style при забросе, потому что вы не можете сказать, цель броска от одного взгляда :)

---

При каких обстоятельствах это гарантированно работает?

Это не real литье между типами.Например,

int i = 5; 
float* f = reinterpret_cast<float*>(&i); 

Теперь f указывает на то же место, что указывает на i. Таким образом, преобразование не производится. Когда вы разыскиваете f, вы получите поплавок с тем же двоичным представлением целого числа i. Это четыре байта на моей машине.

Answer 4

Если две структуры POD начинаются с одной и той же последовательности элементов, стандарт гарантирует, что вы сможете свободно их получить через объединение. Вы можете сохранить A :: Point3D в объединении, а затем читать из члена B :: Point3D, если вы касаетесь только членов, которые являются частью исходной общей последовательности. (поэтому, если одна структура содержала int, int, int, float и другую, содержащую int, int, int, int, вам было разрешено иметь доступ только к трем первым ints).

Таким образом, это похоже на гарантированный способ, которым ваш код должен работать. Это также означает, что литье должно быть, но я не уверен, что это указано в стандарте.

Конечно, все это предполагает, что обе структуры скомпилированы с одним и тем же компилятором для обеспечения идентичного ABI.

Answer 5

Следующая довольно безопасно:

namespace A { 
    struct Point3D { 
    float x,y,z; 
    }; 
} 

namespace B { 
    typedef A::Point3D Point3D; 
} 

int main() { 
    A::Point3D a; 
    B::Point3D* b = &a; 

    return 0; 
}