Explicité l'adresse relative d'une donnée member ? [Résolu]

[LastSpear]

Bonjours à tous !

Je vous sollicite aujourd'hui car je recherche activement une solution. J'aimerais que dans la définition d'une structure, ou d'une classe, je puisse définir explicitement l'adresse relative d'un attribut membre dans un objet. Bien entendu, aillant cherché activement, je n'ai pas réussi à trouver mon bonheur, et m'en remet donc à vous et vos connaissances. (Sinon je ne posterais pas )

Permettez moi de vous expliquer quel en ai le but :

Je dispose de structures pour faire du calcul vectoriel en 2, 3 et 4 dimension.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct vec2
{
  float x;
  float y;
};
 
struct vec3
{
  float x;
  float y;
  float z;
};
 
struct vec4
{
  float x;
  float y;
  float z;
  float w;
};

Or je suis également developeur OpenGL, donc GLSL pour ses shaders, et GLSL propose quelque chose que j'apprécies beaucoup :

Code :

1
2
3
4
5
// code GLSL
vec4 a;
vec2 b = a.xy;
vec2 c = a.yz;
a.zw += b + c.yx;

J'aimerais rendre cela possible en C/C++, et jusque là je m'en sort :

Code :

1
2
3
4
5
// code C++ actuel
vec4 a;
vec2 b = a.xy ( );
vec2 c = a.yz ( );
a.zw ( ) += b + c.yx ( );

Mais j'aimerais pouvoir fair disparaitre les parenthèse pour obtenir une compatibilité entre le code C++ et le code GLSL car, xy et ses copains sont pour le moment des méthodes inline. Et pour cela, j'avais pensez à définir d'avantages de variables membres comme suit :

Code :

1
2
3
4
5
// représentation mémoire de vec4
0x0...00 | float x | vec2 xy |         | vec3 xyz |
0x0...04 | float y | vec2 xy | vec2 yz | vec3 xyz |
0x0...08 | float z | vec2 zw | vec2 yz | vec3 xyz |
0x0...0C | float w | vec2 zw |         |          |

Je n'ai pas mis toutes les combinaisons possible ici par lisibilité.
Si vous avez une solution à me proposer, pour ce résultat je suit preneur !

Je vous remercie de votre lecture, ainsi que de vos réponses éventuelles.

Très cordialement.

[Bousk]

Bonsoir,

peut-être qu'avec des union tu peux arriver à un résultat satisfaisant.

[LastSpear]

Bonsoir,

Tout d'habort, merci du conseil ! Je me suis donc plongé plus profondément dans les unions et ai découvert qu'on pouvait en déclaré des anonymes, de même pour les structures. Ainsi je viens de réussir à l'instant de faire ce que je voulais comme ceci :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
template < class TYPE >
struct vec2_r0
{
	TYPE y : sizeof ( TYPE ) * 8;
	TYPE x : sizeof ( TYPE ) * 8;
};
 
template < class TYPE >
struct vec2_n0
{
	union
	{
		struct
		{
			TYPE x : sizeof ( TYPE ) * 8;
			TYPE y : sizeof ( TYPE ) * 8;
		};
 
		struct
		{
			vec2_r0 < TYPE > yx;
		};
	};
};
 
template < class TYPE >
struct vec2_n1
{
	TYPE x : sizeof ( TYPE ) * 8;
	TYPE : sizeof ( TYPE ) * 8;
	TYPE y : sizeof ( TYPE ) * 8;
};
 
template < class TYPE >
struct vec2_r1
{
	TYPE y : sizeof ( TYPE ) * 8;
	TYPE : sizeof ( TYPE ) * 8;
	TYPE x : sizeof ( TYPE ) * 8;
};
 
 
template < class TYPE >
struct vec3
{
	union
	{
		struct
		{
			TYPE x : sizeof ( TYPE ) * 8;
			TYPE y : sizeof ( TYPE ) * 8;
			TYPE z : sizeof ( TYPE ) * 8;
		};
 
		struct
		{
			vec2_n0 < TYPE > xy;
			TYPE : sizeof ( TYPE ) * 8;
		};
 
		struct
		{
			vec2_r0 < TYPE > yx;
			TYPE : sizeof ( TYPE ) * 8;
		};
 
		struct
		{
			TYPE : sizeof ( TYPE ) * 8;
			vec2_n0 < TYPE > yz;
		};
 
		struct
		{
			TYPE : sizeof ( TYPE ) * 8;
			vec2_r0 < TYPE > zy;
		};
 
		struct
		{
			vec2_n1 < TYPE > xz;
		};
 
		struct
		{
			vec2_r1 < TYPE > zx;
		};
	};
};

Alors cela fonctionne parfaitement lorsque je fait :

Code :

1
2
typedef vec2_n0 < int > ivec2;
typedef vec2_n0 < unsigned int > uvec2;

Mais sa me sort une erreur de compilation pour :

Code :

1
2
typedef vec2_n0 < float > vec2;
typedef vec2_n0 < double > dvec2;

il semble pas aimer ce genre de ligne :

Code :

1
2
float : 32;
double : 64;

Connaitriez vous un moyen pour remédier à ce problème, autre que redéfinir tout les classes dans le cas particulier de float et de double ? Et dans le cas ou TYPE serait une classe ? (pour la gestion de float 128bits par exemple ...)

Aussi, j'aimerai que tout les méthodes disponibles dans vec2_n0 soit aussi disponible dans les autres vec2_XX mais sans faire de copier collé de celles ci, connaitriez vous un moyens ? J'avais pensé à un #include dans la porté de la structure ... Qu'en pensez vous ? N'aurez vous pas quelque chose de plus "propre" ?

[koala01]

Salut,

Fais déjà attention au fait que, tel que tu écris le code, tu obtiens le nombre de bits de tes données membres, ce qui n'est sans doute pas ce que tu souhaites, étant donné que, quoi qu'il arrive, les adresses sont incrémentées par bytes (vu que sizeof(char) == 1 )
(
Ceci dit, il est possible de faire quelque chose de pas mal en rajoutant deux argument template supplémentaires (pour autant que tu veuilles obtenir les membres successifs uniquement):

Le premier serait, par exemple, l'indice de la donnée membre de début et le second serait le nombre des données membres que tu souhaites avoir, sous une forme proche de

Code :

1
2
3
4
5
6
template <typename Data, typename Type , int Index, int Size>
struct SubData
{
      subData(Data * d) {memcpy (data, d+(Index*sizeof(Type), Size);}
      Type data[Size];
};

Ainsi, si tu as un point 3D sous la forme de

Code :

1
2
3
4
5
6
struct Point3D
{
    int x;
    int y;
    int z;
};

tu pourrais définir des alias de types de SubData pour x et y sous la forme de
/* "ancienne" forme */

Code :

1
2
3
4
typedef SubXY SubData<Point3D,int,0,2>;
/* en C++11
using SubXY = SubData<Point3D,int,0,2>;
*/

pour y et z sous la forme de
/* "ancienne" forme */

Code :

1
2
3
4
typedef SubYZ SubData<Point3D,int,1,2>;
/* en C++11
using SubYZ = SubData<Point3D,int,1,2>;
*/

et même pour x, y et z sous la forme de
/* "ancienne" forme */

Code :

1
2
3
4
typedef SubXY SubData<Point3D,int,0,3>;
/* en C++11
using SubXYZ = SubData<Point3D,int,0,2>;
*/

[LastSpear]

Bonjour,

Sa me semble pas mal ce que tu me proposes ... J'achète ! Merci bien !

C'est toujours agréable ce forum et ses réponses de qualités !

Je passe le sujet en résolu.