Discussion :

[romeo9423]

Bonjour,

je dois stocker des informations concernant des fichiers sur une carte à puce. En gros à chaque identifiant fichier je dois associer deux ou trois paramètres.
Par exemple


typedef struct
{
int nFileID;
int nKey;
int nMode;
} TRecInfo;



pour le fichier 0x17 on doit utiliser la clé 0x12 pour lire et utiliser un mode spécifique.

Mon problème est de stocker ces données qui ne dépassent pas un 20n d'éléments puis ensuite de pouvoir récupérer ces données en fournissant l'identifiant fichier: GetRecInfo(0x17) doit me renvoyer les données associées

Que dois-je utiliser ? un tableau de structure, un std::map, un
std::set.
Je veux pouvoir accéder aux données le plus rapidement possible et c'est pour ca que le tableau de structure me paraissait pas mal avec un truc du genre :



TRecInfo recInfo;

recInfo.nKey = 0x12;
recInfo.nMode = 0
m_RecInfo[0x17] = recInfo;

Si je choisis cette solution il n'y a pas une façon plus élégantge d'initialiser ce tableau du genre ?

m_RecInfo[0x17] = new TRecInfo(0x12, 0);

[Luc Hermitte]

Combien d'entrées veux-tu ? Seulement une vingtaine ? Alors un vecteur maintenu trié suffit amplement. On peut alors faire une recherche en O(ln n) avec std::binary_search.
Voire même consommer plus de mémoire que nécessaire afin d'avoir un tableau à trous et d'assurer un accès en O(1). A condition que les index aient un max raisonnable. Dans le genre, il y a les tables de hashage non encore standard.

std::set et std::map assurent des accès en O(ln n). Pour la map, l'index est externe à la donnée stockée.
L'avantage sur les vecteurs étant si il y a beaucoup d'ajouts et retraits. Sinon, cela consomme un petit peu plus de mémoire qu'un vecteur calé au minimum, et le parcours itératif est un chouilla plus lent.

Enfin. Si tu veux un multi indexage (avec toutes les recherches "rapides"), boost.multi_index est une solution (non encore personnellement testée).

PS: le typedef sur les structures est superflu en C++.
PPS: pour trois entiers, faire des news n'est pas forcément utile. Cela demande beaucoup plus d'attention, et je ne suis pas persuadé qu'il y aurait des gains observables. Maintenant, la modélisation du problème peut parfaitement justifier ce choix -- genre si une structure doit être partagée.

[Tarrke]

genre si une structure doit être partagée.

qu'entend tu par là ?

Il se trouve que j'ai un programme qui fonctionne avec des structures pour effectuer une communication entre différentes parties de la modélisation.
Or pour passer mes structures d'une classe à une autre, je les alloue dynamiquement avec new pour être sûr que les données ne seront détruites que lorsque j'aurais terminé de les utilisées. Est-ce une bonne méthode ? y'en a-t-il une autre pour s'assurer que des données ne soient pas détruites par la fin d'un bloc ???

exemple de ce que je fait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
mon_type_de_struct * ma_struct = new mon_type_de_struct;
// remplissage de données
maClasse.setStruct( ma_struct );
return;
 
// dans maClasse :
void setStruct( mon_type_de_struct * ma_struct )
{
  m_structure = ma_struct;
  // stockage pour une utilisation future, lors de l'appel d'un draw par
  // exemple.
}