יש אפשרות לשים מצביעים בתוך union, להקצות להם זיכרון ולצפות שהכל יפעל?
אין לי ממש איך להסביר את זה אז אני פשוט יראה חתיכת קוד:

קוד PHP:

 struct tuple
{
    float x;
    float y;
    float z;
};

union shared_tuple
{
    tuple *t;
    float *d;
};

int main()
{
    shared_tuple st;
    st.t = new tuple[2];
    st.d = new float[6];

    st.t[0].x = 3;
    st.t[0].y = 2;
    st.t[0].z = 1;
    st.t[1].x = 6;
    st.t[1].y = 5;
    st.t[1].z = 4;

    std::cout << st.d[0] << "," << st.d[1] << "," << st.d[2] << "\n";
    std::cout << st.d[3] << "," << st.d[4] << "," << st.d[5] << "\n";

    return EXIT_SUCCESS;
} 


הקוד הזה פועל מסיבה שלא לגמרי ברורה לי. השאלה שלי היא האם הוא תמיד יפעל? גם עם 10000 אינדקסים?

לא משנה.

שאלה טיפה שונה. האם זה בטוח? זה יפעל על כל קומפיילר? אני רוצה לבסס על זה משהו די גדול ולא בא לי לגלות שזה בכלל לא בטוח אחרי (אם) שאני יכתוב את הקוד.

ממש לא בהכרח יפעל. התקן לא מבטיח איך המשתנים בתוך ה-struct ישבו בזיכרון. יכולים להיות ביניהם "רווחים".

חשבתי שהם אמורים להיות כמו שההיגיון אומר כל עוד הם מאותם הסוגים?

אז זהו, שלא...

§9.2.17
A pointer to a POD-struct object, suitably converted using a reinterpret_cast, points to its initial
member (or if that member is a bit-field, then to the unit in which it resides) and vice versa. [Note: There
might therefore be unnamed padding within a POD-struct object, but not at its beginning, as necessary to
achieve appropriate alignment. ]

§9.2.12
Nonstatic data members of a (non-union) class declared without an intervening access-specifier are allocated
so that later members have higher addresses within a class object. The order of allocation of nonstatic
data members separated by an access-specifier is unspecified (11.1). Implementation alignment requirements
might cause two adjacent members not to be allocated immediately after each other; so might
requirements for space for managing virtual functions (10.3) and virtual base classes (10.1).

באופן מעניין, למערכים מובטח שהגודל של מערך של N אלמנטים מטיפוס T יהיה בגודל של N כפול sizeof(T)‎. המשמעות של זה היא שפנייה לאלמנטים שונים של מערך יכולה לקחת זמן שונה, בתלות ב-alignment.

ושוב, אני ממליץ להשיג עותק על התקן. מגלים שם דברים מעניינים.

זה לא באורך של איזה ספר?
בכל מקרה, אם אני עושה pragme pack שלפי הבנתי פועל על הקומפיילרים המרכזיים, זה אמור להיות קבוע?

עם ‎#pragma pack(1)‎ כנראה שזה בסדר.

מסקרן אותי לדעת בישביל מה אתה צריך את זה.
וזה לא תמיד יעבוד, אם תשחק עם טיפוסים שונים עם גדלים שונים אתה תמצא מקרה שזה לא יעבוד...

לייצג כל מיני טיפוסים מתמטיים בצורות שונות. לדוגמא:

קוד PHP:

 struct pairf
{
    float x1;
    float x2;
};

struct matrix2
{
    union
    {
        #pragma pack(1)
        struct
        {
            float m10;
            float m11;
            float m20;
            float m21;
        };

        #pragma pack(1)
        struct
        {
            pairf c1;
            pairf c2;
        };

        float m[4];
    };
}; 


יש כאן יצוג של מטריצה דו מימדית בתור אינדקסים, בתור וקטורי עמודות (או שורות, סתם בחירה שלי) ובתור מערך.
הסיבה העיקרית שאני רוצה את זה היא בשביל מודלים תלת מימדיים.
APIים כמו OpenGL ו D3D רוצים לקבל מערכים של מספרים שמייצגים מודל, אבל זה מעצבן מאוד להתעסק אתם בצורה כזאת. כל שינוי קטן שרוצים לעשות צריך להתחיל להוסיף מספרים ולהכפיל את הiterators, לכן אני רוצה באותו זמן לייצג את המודל בתור וקטורים, רק בלי להחליף בינהם כל הזמן.

לא הגיע הזמן שמישהו בעולם הזה יתקן יצוג של טקסט מימין לשמאל ומשמאל לימין באותה שורה?

נראה לי כמו דרך נפלאה לחרב את כל הtype safty בעולם

תתקן אותי אם אני טועה, אבל מכיוון שכל המשתנים הם מאותו הטיפוס - float, פשוט מסודרים בגדלים שונים, אז המצב לא כזה נורא?
אם יש למישהו רעיון יותר "בטוח" איך לעשות את מה שכתבתי, אז אני אקשיב בשמחה. זה פשוט לא נחמד להצטרך כל רגע לקחת מודל שלם ולהפוף לו יצוגים ידנית (או לשמור על שניהם חיים ואז זה לוקח כפול זיכרון).

לא הבנתי איך זה עוזר לך בישביל לייצג מודל של 1000, על 1000 על 1000...
מה זה נותן לך שאיטרטור לא?

בתוך הפונקציות שלי, אני רוצה להתייחס למודל בתור קבוצה של נקודות, אבל ספריות גרפיות רוצות לקבל רשימה לינארית של ערכים - מערך, במילים אחרות. עד עכשיו עשיתי את כל החישובים על מערך, והדבר היחיד שזה מביא לי זה צרות.

בהצלחה