Discussion :

[Fakboy]

Bonjour à tous,

Je poste ici pour la première fois, je pense...! Donc salutation à tous! Je suis un programmeur vétéran Labview, et un expert en C_ANSI (Vétéran est plus fort que expert pour moi... Le vétéran va sur le champs de bataille, et l'expert reste dans le bunker! J'ai le meilleur des deux mondes, je peux compiler sur des chips de rien du tout ET/OU faire des benchtest de la mort... (donc pitier, pas de débat sur qu'est-ce qui est le mieux...

Bon, voilà... Ce qui me pousse à poster ici, c'est que là j'ai un dilemme depuis 2 semaines et je tourne en rond. Je réalise présentement un programme, principalement en C ANSI, mais compilé avec un compilateur C++, donc avec certaine lib de C++ ET, le but n'est pas d'aller sur un chip, pour l'instant, mais! il est codé «comme si». Vous voyez le genre...!?

Mon prog possède une structure, qui possède un array dynamique d'une autre structure, et elle, possède 1 array 2D dynamique de double...
bon, disons ça... (c'est un exemple...!)

Code :

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

1
2
3
4
5
6
7
8
9
 
struct PETITE_struct{
     int data_size;
     double **data;
};
struct GROSSE_struct{
     int petite_size; //le nombre de petite struct...mettons...
     PETITE_struct *petite;
};

Je fais des malloc() pour toute la gang, tout est ça coche... Le programme roule ça coche aussi.

Là ou je bloque, c'est lors de la sauvegarde... Bon, le choix du C ANSI*ou du C++ importe plus ou moins, mais la préférence va pour le C ANSI... bien sur... Sinon, j'aurais déjà fini en Labview... (merci de comprendre, et de même pas en parler...

Je désire sauvegarder ma structure qui EST de taille dynamique, dans un fichier (idéalement xml, afin de pouvoir modifier les valeurs manuellement et/ou les voir de façon humaine...) Je dis idéalement, parce que au pire, une fonction user_menu pourrait me permettre de modifier les valeurs... mais pas vraiment de les voir... :S
C'est un programme assez lourd en ressource, et je dois rester minimal... Toutefois, l'utilisation du xml reste possible... (ou, je veux bien entendre vos commentaires là dessus...)

Bon, DONC...
Ma question est, quel est la MEILLEURE solution pour «serializer» et «deserializer» ma «GROSSE_struct»...?
par «serializer/deserializer» je veux dire bien sur, «SAUVEGARDER MA*STRUCTURE*DANS UN FICHIER, ET, CHARGER D'UN FICHIER, MES*DONNÉES*ET*LES*METTRE*DANS*MA*STUCTURE»

Bon voilà, j'ai vu qu'en C# c'est telle qu'elle avec les fonction std, mais pas en C/C++... DONC, je me dis que des lib existe pour celà, MAIS, après avoir testé tinyxml et libxml, je suis toujours sceptique sur l'efficacité/nécessité de mon histoire, libxml, trop gros pour simplement sauvegarder une structure, et tinyxml... trop simple pour serializer/deserializer..., Pour le moment, les datas sont sauvegardé en format .txt, le fichier fait 13Mb, et le prog plante lorsque le nombre de data est trop grand... C'est pas trop grave, mais c'est... pas <propre> disons...

Je fais appel à vous, «quel est la meilleur façon actuel en C/C++ de <parser> ET/OU serializer/deserializer une structure/class?»

Mon programme, malgré son besoin énorme en ressource, ne fais que 2 .cpp et 2 .h ... l'utilisation d'une lib «énorme» comme libxml est... douteuse... l'idéal, serait d'inclure dans mes .cpp quelques fonctions qui serializerais/deserializerais...

Le plus long post du monde surement, mais je poste pas souvent, alors je me donne... Si vous avez eu le courage de me lire, BRAVO, et continuons le pouvoir du C/C++ Malgré ses défauts!

Fakboy

[koala01]

Salut, et bienvenue sur le forum.

D'abord, je voudrais dire qu'il est peut être dommage de compiler du C avec un compilo C++ si ce n'est pas pour profiter de l'intégralité de ce que permet C++...

Je comprend parfaitement tes motivations et contraintes (il y a d'ailleurs justement un débat sur le choix de C ou de C++ en embarqué), mais je me demande malgré tout s'il ne serait pas intéressant de tenter l'expérience en "full C++" afin de voir si tu ne respecte malgré tout pas tes contraintes

Je trouve, par exemple, dommage de jouer avec malloc quand new fait aussi bien le travail, ou d'utiliser des pointeurs (voir des pointeurs de pointeurs) lorsque l'on peut utiliser une classe gérant les tableaux dynamiques de manière automatique

Ainsi, je présumes que ton tableau 2D de double est... une matrice pleine et que tu as le même nombre de colonnes pour chaque ligne.

Tu pourrais donc te baser sur le fait que, si tu as L lignes de C colonnes, tu as, purement et simplement, L*C éléments, et donc créer directement un tableau de L*C "unidimentionnel", en accédant à l'élément se trouvant à la ligne l et à la colonne c avec la formule de base pos = l * C + c.

De même, tu pourrais, au lieu de travailler sur tableau dynamique "C style" envisager de travailler avec la classe vector, disponible dans l'espace de nom std par inclusion du fichier d'en-tête <vector>

Tu ta petite structure pourrais donc prendre la forme de

Code :

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

1
2
3
4
5
6
struct PETITE_struct
{
    int lignes;
    int colonnes;
    std::vector<double> data;
};

et être desservie (à défaut d'en faire une classe, avec tout ce que cela implique d'organisation OO) par des fonctions proches de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void initPetite(PETITE_struct & ps, int l, int c)
{
    ps.lignes = l;
    ps.colonnes = c;
    ps.data.resize(l*c);
}
double getValue(PETITE_struct const & ps, int l, int c)
{
    /* assert (l<ps.lignes)
     * assert(c<ps.colonnes)
     */
    return ps.data[ps.colonnes * l + c ];
}

et tu pourrais disposer de la taille totale, soit en multipliant lignes par colonnes, soit directement par la fonction membre size de ... data.

De la même manière, ta grosse structure pourrait ne contenir qu'un... std::vector de PETITE_struct
et prendre la forme de

Code :

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

1
2
3
4
5
6
struct GROSSE_struct{
    /* tu peux obtenir le nombre de PETITE_struct par la fonction membre
     * size ;)
    */
    std::vector<PETITE_struct> petite;
};

(d'ailleurs, tu pourrais tout de suite utiliser un std::vector<PETITE_struct> si GROSSE_struct n'est pas obligatoire )

Ceci étant dit, la façon la plus simple de sérisliser / désérialiser tes données est peut-être d'utiliser... boost.serialize (il y a un tuto sur cette bibliothèque qui traine quelque part sur le site, mais j'ai la flemme de le chercher ).

Mais il faut, là aussi, voir si c'est utilisable en fonction de tes contraintes