Sauvegarde std::map dans un fichier

Version imprimable

30/04/2007, 16h24
ZeRiL

Sauvegarde std::map dans un fichier
Bonjour a tous,

voila je travaille actuellement sur une structure de type :
Code:

1 2 3 typedef vector<vector<float> > Array2D; map<string, Array2D> Files;
donc je fait tous les traitements que j'ai a faire dessus etc. A la fin de mes traitements la map est fixée et normalement je n'y touche plus. J'ai besoin de la sauvegarder de facon permanente afin de pouvoir y acceder par la suite depuis d'autres programmes. Seulement la je seche. Auriez vous une methode a me conseiller ou meme une autre facon de faire, le fait de passer par un fichier n'est peut etre pas la bonne solution...

Merci d'avance.

PS : je ne sais pas si ca joue mais la taille de la map est relativement consequente : environ 48*5 strings de 1000*128 array2D.
30/04/2007, 16h44
ZaaN

le choix memoire morte/vive se fait sur l'hypothese suivante: si ton application ayant rempli la map peut etre terminé alors que les autres application clients aurons besoin de la map, --> memoire morte sinon memoire vive.

ensuite la manière de stocker en memoire morte peut etre la suivante : rediriger ta map vers un ostream/ofstream

Salut,

Si tu es libre du point de vue du format, je me tournerais volontiers vers une des solutions suivantes:

Soit, toutes les lignes contiennent le meme nombre d'éléments, et, dans ce cas, on indiquerait simplement le nombre de lignes et de colones sous la forme de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
//création d'un flux en écriture de fichier
std::ofstream ofs("sauvegarde.txt");
//la premiere ligne contient le nombre de lignes et le nombre de colones
ofs<< mamap.size()<<" "<<mamap[0].size()<<std::endl;
for(unsigned int i=0;i<mamap.size();i++)
{
    for(unsigned int j=0;j<mamap[i].size();j++)
    {
        ofs<<mamap[i][j]<<" ";
    }
    ofs<<std::endl;
}

et la lecture se fait sous la forme d'un

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
 
//création d'un flux en lecture du fichier
std::ifstream ifs("sauvegarde.txt");
unsigned int lignes;
unsigned int colones;
//lecture du nombre de lignes et du nombre de colones
ifs>>lignes>>colones;
//déclaration de la map
std::vector<std::vector<float> > tab;
//boucle qui s'occupe de gérer les lignes
for(unsigned int i=0;i<lignes;i++)
{
     // un tableau de float temporaires ;)
     std::vector<float> temp;
    //boucle qui s'occupe de gérer les colones
    for(unsigned int j=0;j<colones;j++)
    {
        float f;
        ifs>>f;
        temp.push_back(f);
    }
    // on a lu toutes les colones de la ligne, on peut l'insérer dans la
    // matrice
    tab.push_back(temp);
}

Soit, le nombre de colones est différent en fonction de la ligne en cours de la matrice, et il faut donc indiquer, pour chaque lignes, combien de colones doivent etre lue...

A l'écriture, cela donnerait

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
std::ofstream ofs("sauvegarde.txt");
//la premiere ligne contient le nombre de lignes
ofs<< mamap.size()<<std::endl;
for(unsigned int i=0;i<mamap.size();i++)
{
    // écriture du nombre de colones de la ligne
    ofs<<mamap[i].size();
    for(unsigned int j=0;j<mamap[i].size();j++)
    {
        ofs<<mamap[i][j]<<" ";
    }
    ofs<<std::endl;
}

et en lecture

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
 
//création d'un flux en lecture du fichier
std::ifstream ifs("sauvegarde.txt");
unsigned int lignes;
//lecture du nombre de lignes
ifs>>lignes
//déclaration de la map
std::vector<std::vector<float> > tab;
//boucle qui s'occupe de gérer les lignes
for(unsigned int i=0;i<lignes;i++)
{
     // un tableau de float temporaires ;)
     std::vector<float> temp;
    //boucle qui s'occupe de gérer les colones
    //lecture du nombre de colones
    unsigned int colones;
    ifs>>colones;
    for(unsigned int j=0;j<colones;j++)
    {
        float f;
        ifs>>f;
        temp.push_back(f);
    }
    // on a lu toutes les colones de la ligne, on peut l'insérer dans la
    // matrice
    tab.push_back(temp);
}

Le fichier résultant serait, dans le premier cas, du genre de

Code:

1
2
3
4
5
 
3 5
0.2158 0.4448 0.66698 0.8888777 2.8721
...(chaque fois 5 valeurs ;))
...

(ou le 3 représente le nombre de lignes et le 5 le nombre de colones)
et dans le second du genre de

Code:

1
2
3
4
5
 
3
5 0.2158 0.4448 0.66698 0.8888777 2.8721
2 5.89666 4.888
4 3.0245 2.0368 1.55580 4.77741

(ou le 3 du début représente le nombre de lignes et où le premier nombre de chaque ligne représente celui des colones de la lignes ;))

Simple et efficace... meme s'il est possible de compresser le code sous la forme d'un std::copy, par exemple ;)

02/05/2007, 09h48
ZeRiL

Merci beaucoup a vous deux et surtout a Koala01 de m'avoir meme propose un code :) desole de ne pas avoir repondu plus rapidement mais hier c'etait ferie ;)

Sur ce je vais tester le code avant de mettre ce post en Resolu [Meme si je ne doute pas que ce soit le cas dans quelques minutes :P ]

- Edit - Oops je viens de m'apercevoir que j'avais un gros pb dans mon prog, je doit regler ca avant. Je pense tester la sauvegarde dans la journee.
03/05/2007, 11h15
ZeRiL

Impeccable ca marche nikel merci a toi Koala01, j'ai juste une derniere question : est-il possible d'ouvrir le fichier de sauvegarde en ajout (ca m'arrangerais beaucoup xD) ?
03/05/2007, 11h22
Laurent Gomila

Citation:

est-il possible d'ouvrir le fichier de sauvegarde en ajout

Oui, jette un oeil aux options que tu peux passer en second paramètre du constructeur de ofstream (genre ios::app).
03/05/2007, 11h52
ZeRiL

Teste & approuve. Merci a tous.

Heuu... sois juste attentif au fait que, si tu fais un ajout, le nombre de lignes risque de ne plus correspondre... (si tu utilise mon idée de "fournir" ce nombre de lignes)

Par contre, si tu envisage l'utilisation de plusieurs matrices différentes, cela peut se traduire, au final, par un fichier du genre de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 3 5 (il y a trois lignes de cinq colones dans la premiere matrice) contenu de la premiere ligne contenu de la deuxieme ligne contenu de la troisieme ligne 5 5 (la deuxieme matrice est composée de 5 lignes de 5 colones ... ... ... ... ... 6 10 ...
Si tu veux que ta matrice, qui était à l'origine de 5 par 5 devienne une matrice de 10 par 5 (ou pire, de 10 par 10), il ne s'agira pas de se contenter d'ajouter les valeurs dans le fichier, il faudra quarément le réécrire entierement ;)

Ou, du moins, dans toute autre hypothese que celle qui voudrait que

tu sache dés le départ que ta matrice fera 10 par 10 mais
tu va remplire les lignes les unes apres les autres, et tu voudrais les écrire dans ton fichier au fur et à mesure...

Oui merci Koala01 effectivement j'ai du trouver une solution mais qui est au final toute simple : vu que j'ai une matrice par fichier que je traite, j'ai rajoute un niveau de vecteur afin d'avoir chaque matrice associee au nom de fichier, lorsque je sauvegarde, cela me donne quelque chose de style :
Code:

1 2 3 4 5 6 7 8 9 10 11 titi.jpg 100 //100 vecteurs de vecteurs dans le fichier titi.jpg 14 132 //14 vecteurs de 132 float dans le vecteur de vecteurs [0] //1er vecteur de float //2eme vecteur de float //etc 7 132 //7 vecteurs de 132 float dans le vecteur de vecteurs [1] //etc toto.jpg 150 //150 vecteurs de vecteurs dans le fichier de nom toto.jpg //... //...
Le seul truc que je n'ai pas encore teste c'est de lire fichier par fichier dans la sauvegarde, mais je ne pense pas que ce soit un probleme :).
En tout cas merci encore, c'est parfait ^-^