La lettura di un membro di unione inattivo dello stesso tipo di uno attivo è ben definito?

Question

Si consideri la seguente struttura:

struct vec4 
{ 
    union{float x; float r; float s}; 
    union{float y; float g; float t}; 
    union{float z; float b; float p}; 
    union{float w; float a; float q}; 
}; 

Qualcosa di simile sembra essere usato per esempio in GLM a fornire tipi GLSL-come come vec4, vec2 ecc ..

Ma anche se l'utilizzo previsto è come per rendere questo possibile

vec4 a(1,2,4,7); 
a.x=7; 
a.b=a.r; 

, che sembra essere un comportamento indefinito, perché, come citato here ,

In un sindacato, al massimo uno dei membri di dati può essere attivo in qualsiasi momento, ovvero il valore di al massimo uno dei membri di dati può essere memorizzato in un'unione in qualsiasi momento.

Non sarebbe meglio ad es. usa solo definire la struttura qualcosa come la seguente?

struct vec4 
{ 
    float x,y,z,w; 
    float &r,&g,&b,&a; 
    float &s,&t,&p,&q; 
    vec4(float X,float Y,float Z,float W) 
     :x(X),y(Y),z(Z),w(W), 
     r(x),g(y),b(z),a(w), 
     s(x),t(y),p(z),q(w) 
    {} 
    vec4() 
     :r(x),g(y),b(z),a(w), 
     s(x),t(y),p(z),q(w) 
    {} 
    vec4(const vec4& rhs) 
     :x(rhs.x),y(rhs.y),z(rhs.z),w(rhs.w), 
     r(x),g(y),b(z),a(w), 
     s(x),t(y),p(z),q(w) 
    {} 
    vec4& operator=(const vec4& rhs) 
    { 
     x=rhs.x; 
     y=rhs.y; 
     z=rhs.z; 
     w=rhs.w; 
     return *this; 
    } 
}; 

Oppure sto lavorando su un problema inesistente? C'è forse qualche dichiarazione speciale che consente l'accesso a membri sindacali inattivi identicamente tipizzati?

Answer 1

Penso che la citazione a cui ti riferisci sia diretta ad avere tipi diversi con l'unione.

Questi sono dati diversi, convenientemente memorizzati nella stessa struttura, i sindacati non dovrebbero essere un meccanismo di fusione.

L'approccio GLM utilizza gli stessi dati e utilizza l'unione per una meccanica alias.

Il tuo approccio potrebbe essere 'migliore' C++ ma è peggio 'Ingegneria'. La matematica vettoriale deve essere veloce, e più piccola è la migliore in questo caso.

L'implementazione rende il vettore 3 volte più grande. sizeof(glm::vec4); // 16 while sizeof(your_vec4); // 48 - ouch Se si sta elaborando un grande numero di questi, il che è spesso il caso, 3 volte più manca la cache con your_vec4.

Penso che tu abbia ragione anche se l'uso di glm dei sindacati come alias è un po 'troppo, mentre non sono sicuro se è indefinito, ma questo tipo di cosa ho visto molto senza molto problema, e glm è ampiamente Usato.

Non vedo davvero la necessità di emulare glsl in C++, e struct { float x,y,z,w; } sarebbe meglio (almeno nella mia mente).