taille des structures

Version imprimable

Voila mon probleme, je n'arrive pas a definir la taille de mes structures, ce qui est problematique pour certaines operations.

Mon compilo est un mingw.
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 int main () { struct struct1 { unsigned short type; }; struct struct2 { unsigned long fileSize; }; struct struct3 { unsigned short type; unsigned short fileSize; }; struct struct4 { unsigned short type; unsigned long fileSize; }; struct struct5 { unsigned long type; unsigned long fileSize; }; struct struct6 { unsigned char type; unsigned char fileSize; }; struct struct7 { unsigned char type; unsigned short fileSize; }; struct struct8 { unsigned char type; unsigned long fileSize; }; std::cout << sizeof(struct struct1) << '\n'; std::cout << sizeof(struct struct2) << '\n'; std::cout << sizeof(struct struct3) << '\n'; std::cout << sizeof(struct struct4) << '\n'; std::cout << sizeof(struct struct5) << '\n'; std::cout << sizeof(struct struct6) << '\n'; std::cout << sizeof(struct struct7) << '\n'; std::cout << sizeof(struct struct8) << '\n'; return 0; }
le resultat :
Code:

1 2 3 4 5 6 7 8 2 4 4 8 8 2 4 8
On dirait qu'il "aligne" la taille du plus petit type sur le plus grand.

Je doit avouer etre un peut paumé, ce que je croyais etre absolu ne l'est plus :calim2:

Une explication ? Une solution ?

edit: Voila ce que j'ai trouvé :

Citation:

Mauvais design. Une structure C n'est absolument pas faite pour mapper un
flux de bytes (la preuve).

21/10/2009, 15h37
Nogane

Bonjours,
Tes tailles sont normal, et s'explique par l'alignement mémoire de tes variable.

Par exemple, avec ta structure struct4, ton long nécessite un alignement de 4, et se trouve après ton short, donc le compilo rajoute deux octets entre les deux pour que tout ce passe bien.

Quel problème ce te pose exactement?
21/10/2009, 15h49
nemodev
Un classique :oops: probleme de lecture de fichiers.

Par exemple, lire 50 octets et les mapper dans ma structure. Je croyais ca possible.

J'ai trouvé quelques pistes mais pas encore de solution.

Si je lis les 50 octets dans un unsigned char tab[50], comment prendre les octets 3,4,5,6 et les assigner a un unsigned long ?
Code:

1 2 unsigned long ul; ul = tab[3]
C'est portable ca ? Une autre solution ?
21/10/2009, 15h59
3DArchi

Citation:

Envoyé par nemodev

C'est portable ca ?

Non. Tu auras des problèmes d'alignement et d'endian.

Citation:

Envoyé par nemodev

Une autre solution ?

Boost.Serialize

Merci. Moi qui croyais pouvoir etre flemmard sur ce coup :lol:

J'ai trouvé ca aussi:
Code:

1 2 3 4 5 6 #pragma pack(push, 1) struct struct8 { unsigned char type; unsigned long fileSize; }; #pragma pack(pop)

21/10/2009, 16h09
Nogane
A non ca ne marche pas et en plus ca ne serai pas portable.

Les principales solutions me venant a l'esprit c'est:
- Passer par les flux et un fichier text.
La lecture et l'écriture sont simple, sure, et portable, exemple:
Code:

1 2 3 fstream archive("archive.txt"); archive << Struct3.type << " " << Struct3.fileSize; archive >> Struct3.type >> " " >> Struct3.fileSize;
- Passer par un fichier xml(Par exemple avec TinyXml, pour faire simple). Le principale avantage par rapport au flux, c'est que ton fichier XML peut avoir une structure très complexe, avec une arborescence, et des attribut nommé.

- Utiliser boost::serialization. Personnellement j'adore cette librairie. On peut au choix enregistrer en xml, en text ou en binaire sans rien change dans les class sérialisées. Elle gere l'évolution des class, les class polymorphique, et des tas d'autre chose bien pratique.

Ce sont trois méthodes que j'utilise couramment, et je dirais que le choix dépend du contexte.

EDIT: le #pragma pack(push, 1) ne marche que sous visual il me semble, de plus ca ne gère pas l'endian, ni les différence d'encodage des nombre a virgule flottantes.
21/10/2009, 16h12
nemodev

Depuis le temp, il va bien falloir me mettre a boost. Je dois avoir le gene de la flemme :mouarf:

Marche sur mingw, pas testé avec les floatants.

Merci pour tout, et à la prochaine pour de nouvelles aventures :ccool:
21/10/2009, 16h28
Nogane

Citation:

Marche sur mingw, pas testé avec les floatants.

Mais ta solution n'est toujours pas portable...

Citation:

Merci. Moi qui croyais pouvoir etre flemmard sur ce coup

Passer par un bon vieux ifstream/ofstream est certainement la solution la plus simple que je connaisse.
21/10/2009, 16h58
Médinoc

Citation:

Envoyé par Nogane

Passer par un bon vieux ifstream/ofstream est certainement la solution la plus simple que je connaisse.

Mais avec ça, tu auras du mal à ouvrir un fichier dont tu ne maitrises pas le format, comme une image bitmap...
21/10/2009, 17h05
Nogane

Non bien sur. Je suis parti de la supposition que nemodev avait le choix du format.
Si le format est imposé aucune des solutions proposées n'est viable. Et dans tout les cas il faudra gérer l'endian, se qui fait qu'on devra lire attribut par attribut. Ce qui fait que le #pragma pack(push, 1) n'auras toujours pas d'intérêt.
21/10/2009, 17h34
nemodev

Le format que je veux lire est bien un bitmap, donc pas de float :aie:

En fait pour le pragma, je pensais utiliser un fread sur ma struct. C'est pour ca que j'ai lancé ce topic a la base.

Je dois vous avouer n'avoir encore jamais été confronté à l'endianness :aie:
21/10/2009, 17h45
Médinoc
Pour les bitmaps, Microsoft a tendance à pousser l'endianness sous le tapis et recommander ses structures packed BITMAPFILEHEADER et BITMAPINFOHEADER, bien qu'elles ne marchent directement que sur un système little-endian.

Bien sûr, rien n'empêche de retraiter derrière, par exemple:
Code:

1 2 fread(&maStructure, sizeof maStructure, 1, fichier); maStructure.monChamp = ConvertLittleEndianToHostEndianness32(maStructure.monChamp);

Je voulais me passer des structures windows, mon code devant tourner sous win et linux. Quand je peux je m'en passe.

Voila, ce que je voulais faire, mais le vilain utilise des DWORD, WORD et LONG :

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
#include "fstream"
class Bitmap
{
private:
	unsigned long BPP;
	unsigned long width;
	unsigned long height;
	unsigned long size;
	unsigned char *bitmap_Image;
	unsigned int bps;
	GLuint KompressionFormat;
 
 public:
	 Bitmap();
	 ~Bitmap();
 
	 void *LoadBitmap(const char *Filename);
	 void Load8BitKompression(const char *Filename);
	 void Load24BitKompression(const char *Filename);
 
	 #define BI_RGB   0L
	 #define BI_RLE4  2L 
	 #define BI_RLE8  4L
 
	 #pragma pack(push,1);
	 //BITMAPFILEHEADER
	 typedef struct 
	 {
	 WORD bfType;
	 DWORD bfSize;
	 DWORD bfReserved;
	 DWORD bfOffBits;
	 }BITMAPFILEHEADER;
 
	 //BITMAPINFOHEADER
	 typedef struct 
	 {
	 DWORD biSize;
	 LONG biWidth;
	 LONG biHeight;
	 WORD biPlanes;
	 WORD biBitCount;
	 DWORD biCompression;
	 DWORD biSizeImage;
	 LONG biXPelsPerMeter;
	 LONG biYPelsPerMeter;
	 DWORD biClrUsed;
	 DWORD biClrImportant;
	 }BITMAPINFOHEADER;
 
   	 #pragma pack(pop);
 
	 void Kompression();
 
	 BITMAPFILEHEADER FileHeader;
	 BITMAPINFOHEADER InfoHeader;
};
 
Bitmap::Bitmap()
{
	BPP=0;
	width=0;
	height=0;
	bitmap_Image=NULL;
	size=0;
	bps=0;
	KompressionFormat=0;
}
 
Bitmap::~Bitmap()
{
	BPP=NULL;
	width=NULL;
	height=NULL;
	delete[] bitmap_Image;
	KompressionFormat=NULL;
	size=NULL;
	bps=NULL;
}
 
void *Bitmap::LoadBitmap(const char *Filename)
{
 Bitmap o_Bitmap;
 FILE *File=NULL;
 unsigned int ImageIdx=0;
 unsigned char *bitmap_Image=NULL;
 
 if(!Filename)
 {
	MessageBox(NULL,"Konnte Filename nicht finden!","Error",MB_OK|MB_ICONERROR);
	return false;
 }
 else
 {
	File=fopen(Filename,"rb");
	if(!File)
	{
	 MessageBox(NULL,"'File' hat keinen Inhalt!","Error",MB_OK|MB_ICONERROR);
	 return 0;
	}
 }
 
  fread(&o_Bitmap.FileHeader,sizeof(BITMAPFILEHEADER),1,File);
 if(ferror(File))
 {
	MessageBox(NULL,"'FileHeader' konnte nicht gelesen werden!","Error",MB_OK|MB_ICONERROR);
	fclose(File);
	return 0;
 }
 
 
  fread(&o_Bitmap.InfoHeader,sizeof(BITMAPINFOHEADER),1,File);
 if(ferror(File))
 {
	MessageBox(NULL,"'InfoHeader' konnte nicht gelesen werden!","Error",MB_OK|MB_ICONERROR);
	fclose(File);
	return 0;
 }
 
 fseek(File,o_Bitmap.FileHeader.bfOffBits,SEEK_SET);
 if(ferror(File))
 {
	MessageBox(NULL,"Zu 'bfOffBits' konnte nicht gesprungen werden!","Error",MB_OK|MB_ICONERROR);
	fclose(File);
	return 0;
 }
 
 if(o_Bitmap.InfoHeader.biSizeImage != 0)
 {
	 bitmap_Image=new unsigned char[o_Bitmap.InfoHeader.biSizeImage];
	fread(bitmap_Image,o_Bitmap.InfoHeader.biSizeImage,1,File);
 }
 
 if(o_Bitmap.FileHeader.bfType != 0x4D42)
 {
	MessageBox(NULL,"Ungültiges Bildformat!","Error",MB_OK|MB_ICONERROR);
	fclose(File);
 }
 
  if(!bitmap_Image)
 {
	free(bitmap_Image);
	fclose(File);
 }
 
 if(bitmap_Image==NULL)
 {
	fclose(File);
 }
 
  switch(o_Bitmap.InfoHeader.biCompression)
  {
  case BI_RGB:
	   MessageBox(NULL,"Standardkompression ist aktiviert 'BI_RGB'!","Info",MB_OK);
	   break;
 
  case BI_RLE4:
	   Load8BitKompression(Filename);
	   break;
 
  case BI_RLE8:
	   Load24BitKompression(Filename);
	   break;
 
  default:
	  MessageBox(NULL,"Keine Kompression vorhanden","Error",MB_OK|MB_ICONERROR);
  }
 
 fclose(File);
};
 
void Bitmap::Load8BitKompression(const char *Filename)
{
	Bitmap o_Bitmap;
	FILE *File=NULL;
	MessageBox(NULL,"'BI_RLE4'-Kompression ist aktiviert!","Info",MB_OK);
	File=fopen(Filename,"rb");
    fread(&o_Bitmap.FileHeader,sizeof(BITMAPFILEHEADER),1,File);
	fread(&o_Bitmap.InfoHeader,sizeof(BITMAPINFOHEADER),1,File);
 
	if(FileHeader.bfType != 8)
	{
		MessageBox(NULL,"8-Bitzustand konnte nicht gefunden werden!","Error",MB_OK|MB_ICONERROR);
		fclose(File);
	}
 
	BPP=o_Bitmap.InfoHeader.biBitCount; 
	width=o_Bitmap.InfoHeader.biHeight;
	height=o_Bitmap.InfoHeader.biHeight;
	KompressionFormat=GL_RGB;
 
	if(InfoHeader.biSizeImage != 0)
	{
		bitmap_Image=new unsigned char[o_Bitmap.InfoHeader.biSizeImage];
		fread(bitmap_Image,o_Bitmap.InfoHeader.biSizeImage,1,File);
	}
 
};
 
void Bitmap::Load24BitKompression(const char *Filename)
{
	Bitmap o_Bitmap;
	FILE *File=NULL;
    MessageBox(NULL,"'BI_RLE8'-Kompression ist aktiviert!","Info",MB_OK);
	File=fopen(Filename,"rb");
    fread(&o_Bitmap.FileHeader,sizeof(BITMAPFILEHEADER),1,File);
	fread(&o_Bitmap.InfoHeader,sizeof(BITMAPINFOHEADER),1,File);
 
	if(o_Bitmap.FileHeader.bfType != 24)
	{
		MessageBox(NULL,"24-Bitzustand konnte nicht gefunden werden!","Error",MB_OK|MB_ICONERROR);
		fclose(File);
	}
 
	BPP=o_Bitmap.InfoHeader.biBitCount; 
	width=o_Bitmap.InfoHeader.biHeight;
	height=o_Bitmap.InfoHeader.biHeight;
	KompressionFormat=GL_COLOR_INDEX;
};

Ca a l'air de tourner. M'en voulez pas si j'utilise pas la serialization :aie:

21/10/2009, 19h22
JolyLoic
Si tu veux faire de la sérialisation binaire, portable (tenant compte de l'endianess, des OS 32 et 64 bits...), a peu près la seule chose que tu peux écrire dans un fichier sans problèmes, c'est le contenu d'un tableau d'unsigned chars.

Ensuite, la question vient de savoir comment remplir ce tableau. C'est un des rares cas où j'utilise les opérateur bit à bit.

Par exemple, si j'ai un int sur 4 octets, et que la specs du fichier indique qu'ils doivent être dans l'ordre 3421 (1 étant le LSB, 4 le MSB), j'écris du code genre :
Code:

1 2 3 4 5 6 int i = 42; // Hypothèse : int est sur 32 bits unsigned char buffer[4]; buffer[3] = i & 0xFF; i >> 8; buffer[2] = i & 0xFF; i >> 8; buffer[0] = i & 0xFF; i >> 8; buffer[1] = i & 0xFF;
21/10/2009, 20h20
Mac LAK

Citation:

Envoyé par JolyLoic

Ensuite, la question vient de savoir comment remplir ce tableau. C'est un des rares cas où j'utilise les opérateur bit à bit.

C'est même la seule solution pour lire un entier non-aligné sur des machines qui explosent sur les accès non-alignés, comme les Solaris avec CPU Sparc...
21/10/2009, 22h25
nemodev

Merci pour la soluce :ccool: :ccool: :ccool: