Discussion :

[nemodev]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Une explication ? Une solution ?


edit: Voila ce que j'ai trouvé :

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

[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?

[nemodev]

Un classique 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
unsigned long ul;
ul = tab[3]

C'est portable ca ? Une autre solution ?

[3DArchi]

C'est portable ca ?

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

Une autre solution ?

Boost.Serialize

[nemodev]

Merci. Moi qui croyais pouvoir etre flemmard sur ce coup

J'ai trouvé ca aussi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[nemodev]

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

Marche sur mingw, pas testé avec les floatants.

Merci pour tout, et à la prochaine pour de nouvelles aventures

[Nogane]

Marche sur mingw, pas testé avec les floatants.

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

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.

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.