Discussion :

[avionic]

Salut a tous,
je suis entrain de vouloir ecrire une routine qui me permetra de telecharger un fichier binaire.
le fichier a telecharger a une structure bien defini.
ce qui fait que ma routine va se servir de la structure du fichier a telecharger que j ai eu a definir ci- dessous pour le reconaitre.
maintenant il me suffit d ecrire une routine LoadFichier(). et par la suite ce fichier sera analyser.
Au faite il s agit d un Projet MFC VS 2008.

j´ai eu a penser a utiliser les iterator et les maps!!
quelqu´un peu m aider?
Merci d´avance

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
struct Frame
{
	unsigned int framePattern;
	unsigned int frameLength;
 
	// Pointer auf entsprechendes FrameObjekt
	FTime		*cTime;
	FType		*fType;
	FID			*fID;
	FData		*data;
 
	void Init()
	{
		framePattern = 0;
		frameLength = 0xFFFF;	// 2KByte lang
		cTime = NULL;
		fType = NULL;
		fID = NULL;
		data = NULL;
	}
};
 
 
struct FTime  // 32-Bit lang
{
	unsigned int dataLength;
	FTime()
	{
		dataLength = 0xFFFFFFFF;
	}
};
 
struct FType
{
	unsigned int dataLength;
	FType()
	{
		dataLength = 0xFF;  // 8-Bit lang
	}
};
 
struct FID
{
	unsigned int dataLength;
	FID()
	{
		dataLength = 0xFF;	// 8-Bit lang
	}
};
 
struct FData
{
	unsigned int dataWert;
	FData()
	{
		dataWert = 0xFFFF;
	}
};

[LittleWhite]

Bonjour,

Quel est votre soucis précisément ? Vous ne savez pas comment télécharger vos données ? Ou vous ne savez pas comment structurer vos données ?

[avionic]

Pour plus d explication. j ai un fichier de donné que je dois analyser. et pour cela il me faut ecrire un programme qui va le telecharger et ensuite l analyser.
pour ecrire cette routine LoadData() de telechargement j ai eu a definir la structure du fichier a telecharger. Now il me faut ecrire une fonction qui permettra de reconaitre le fichier pendant le telechargement.

[koala01]

Salut,

Il y a un gros problème avec cette structure : quatre données sur six sont des pointeurs. Or, les chances pour que deux machines distantes utilisent déjà une adresse identique pour représenter une seule donnée identique sont déjà faibles (allez, mettons de taille de la structure / taille de la mémoire, en première approche, on doit pas être si loin que ca d'une valeur correcte ) Alors, tu penses bien que les chances que deux machines distantes utilise exactement les mêmes adresses pour N donnéees deviennent infinitésimales .

Il y a donc déjà forcément "quelque chose à faire" de ce coté là, par exemple, en s'assurant que chaque donnée FTime, FType, FID et FData puisse être identifié de manière unique, non ambigue et reproductible.

Ensuite, il faut te dire que, quelles que soient les données envoyées sur le réseau, ce ne sont jamais que des successions de bytes. A part le fait de vérifier si la taille totale du fichier correspond bien à Nombre De données * taille de données + nombre de byte extra, tu ne sauras pas vérifier grand chose sous cette forme. Et c'est loin de t'apporter une quelconque certitude, vu qu'il y a sans doute énormément de raisons qui pouaient faire qu'un fichier fasse cette taille particulière.

Pour te donner un minimum de sécurité et t'assurer un minimum de ne pas risquer de te retrouver avec trop de faux positifs, il faudra sans doute prévoir la présence d'un (ou mieux, de plusieurs) "nombre(s) magique(s)" à des positions bien particulières.

Tu peux, par exemple, dire que les bytes 12 à 18 doivent représenter une chaine de caractères donnée, que les bytes 20 à 24 doivent représenter un entier non signé de telle valeur constante, ou que sais-je
tu peux aussi dire, par exemple que les bytes 25 à 28, 29 à 33, 34 à 37, 38 à 41 et 42 à 45 correspondent respectivement au nombre d'éléments de type Frame, FTime, FType, FID et FData qui composent ce fichier et qu'ils faut retrouver ces valeurs à certains endroits clé (par exemple, avant de retrouver justement bytes qui correspondent à ces données particulières).

Tu peux aussi rajouter des sommes de redondance cyclique : tous les N byte, tu rajoute m bytes qui correspondent à la somme des N bytes réduite à m bytes (pas évident à expliquer autrement, je te donne un exemple, si tu veux )

Mais quoi qu'il en soit, ce sera rarement la structure de tes données qui t’apportera la garantie que tu cherches à obtenir