Discussion :

[zizoufoot]

Bonsoir,

Désolé pour le titre du post, je n'en ai pas trouvé de mieux.

Pour faire simple :
* J'ai plusieurs fichiers qui contiennent chacun une suite d'enregistrements
* Tous les enregistrement d'un fichier possèdent une même structure. Ceux-ci ont un champ identifiant qui rend unique chaque enregistrement.
NB : Tous les fichiers n'ont pas la même structure pour les enregistrements
* J'ai une fonction qui récupère des informations de l'utilisateur et les stocke dans un tableau de void*

D'après vous, quel est la meilleure façon d'implémenter les opérations suivantes ? :
* Insertion d'un enregistrement dans un fichier
* Modification d'un enregistrement d'un fichier
* Suppression d'un enregistrement d'un fichier

J'ai une solution qui consiste à :
* Créer une structure type qui arrive à définir n'importe quel type de structure utilisés par les enregistrements
* Fournir à chacune de ces 3 fonctions la définition de la structure des enregistrements, le handle du fichier et le tableau contenant les informations de l'utilisateur
* Avant toute opération, chacune de ces trois fonctions convertit le tableau en une suite d'octet
* Chacune des trois fonctions utilise une sous fonction file_Insert/file_Modif/file_Delete à qui on ne transmet que le tableau convertit et le handle du fichier

Cependant, je trouve ma solution lourde.. C'est pourquoi je vous demande votre avis

Merci.

[Neckara]

Bonjour,

As-tu le code de ta solution qu'on puisse voir d'un peu plus près ce que tu fais ?

Attention en convertissant le tableau en une suite d'octet surtout pour les pointeurs et les entiers.
En effet, il ne faut pas stocker le pointeur mais le contenu pointé par le pointeur. De plus, pour les nombres, la taille et l'endianness peut changer.
C'est pourquoi je te recommande d'utiliser htonl ainsi que des types dont la taille est connue comme int64_t.

Sinon pour stocker tes objets, je te conseillerais de regarder du côté de l'XML (ça peut toujours être utile ) mais aussi et surtout de noter un "numéro de version" car ta structure peut changer au fil du temps (un attribut rajouté/enlevé), il te suffit juste d'incrémenter le numéro de version à chaque modifications impactant la lecture/écriture/traitement du fichier et de la noter dans ton fichier, ainsi tu seras au mieux toujours capable de lire d'anciennes versions ou au pire, avertir l'utilisateur que sa version est obsolète.

[mith06]

Salut,

* Créer une structure type qui arrive à définir n'importe quel type de structure utilisés par les enregistrements

SUPER!

* Fournir à chacune de ces 3 fonctions la définition de la structure des enregistrements, le handle du fichier et le tableau contenant les informations de l'utilisateur

NIKEL!

* Avant toute opération, chacune de ces trois fonctions convertit le tableau en une suite d'octet

Un tableau est déjà une suite d'octets.....

* Chacune des trois fonctions utilise une sous fonction file_Insert/file_Modif/file_Delete à qui on ne transmet que le tableau convertit et le handle du fichier

TRES BIEN!!

Cependant, je trouve ma solution lourde.. C'est pourquoi je vous demande votre avis

Lourd pourquoi ? ça a l'air bien ce que tu fais!

[zizoufoot]

Merci pour vos deux réponses.

Voici ma solution actuelle que je vous ai très grossièrement simplifiée:

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
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
typedef struct FIELD FIELD;
struct FIELD {
    char name[10];
    TYPE type;
    int size;
};
 
typedef struct RECORD {
    char name[10];
    FIELD* field;
    int nbFields;
	int totalSize;
    FILE* storage;
} RECORD;
 
char* infosToRaw(RECORD*, void**);
void** rawToInfos(RECORD*, char*);
void insert(RECORD*, void**);
void modif(RECORD*, void**);
void delete(RECORD*, int);
void fileInsert(FILE*, char*, int);
void fileModif(FILE*, int, char*, int);
void fileDelete(FILE*, int, int);
 
int main(void)
{
	void** tableauDInformations;
	RECORD* record;
 
	// Menu choisissant le fichier dans lequel travailler
 
	// Initialisation de record en fonction du fichier traité
 
	// On sait dans quel fichier travailler, donc on sait le nombre d'informations à récupèrer
 
	// Récupèration des différentes informations que l'utilisateur entre
	// Chaque information est stocké dans une zone mémoire allouée
	// Chaque pointeur de ces informations est stocké dans tableauDInformations(réalloué dynamiquement)
 
	// En fonction du sous-menu :
	insert(record, tableauDInformations);
	ou
	modif(record, tableauDInformations);
	ou
	delete(record, identifiantDuRecordASupprimer);
 
	return 0;
}
 
char* infosToRaw(RECORD* record, void** infos)
{
	// encode infos en un pointeur de char contenant les informations les unes à la suite des autres
	// suivant la structure dans record
}
 
void** rawToInfos(RECORD* record, char* raw)
{
	// encode raw en un pointeur de pointeur d'informations suivant la structure dans record
}
 
void insert(RECORD* record, void** infos)
{
		char* raw = infosToRaw(record, infos);
 
		fileInsert(record->storage, raw, record->totalSize);
}
 
void modif(RECORD* record, void** infos)
{
		char* raw = infosToRaw(record, infos);
 
		fileModif(record->storage, raw, record->totalSize);
}
 
void delete(RECORD* record, int id)
{
		char* raw = infosToRaw(record, infos);
 
		fileDelete(record->storage, raw, record->totalSize);
}
 
void fileInsert(FILE* file, char* toInsert, int size)
{
	// Insère toInsert suivant une certaine organisation
}
 
void fileModif(FILE* file, int idToModif, char* toModif, int size)
{
	fileDelete(file, idToModif, size);
	fileInsert(file, toModif, size);
}
 
void fileDelete(FILE* file, int toDelete, int size)
{
	// ftruncate le fichier à la position toDelete*size
}

Edit : Pour répondre à la question précédente, je trouve ça lourd car toutes les structures possibles pour les enregistrements sont définies dans le code. Je pourrais tout aussi bien faire une fonction d'insertion/modification/suppression pour chaque type de structure. Ca irait beaucoup plus vite au niveau de l'exécution et ça enlèverait pas mal de complexité.. Mais ça augmente un peu la taille du code entier.