[boost::serialization] Problème pour sérialiser ma classe.

Hoy!

Je reprend mon Ode et vous montre du vilain code. =p (smieux que le retour qui joue des mauvais tours.)

Le topo : Je boss sur un jeu, et j'ai besoin de mettre des données de jeu sur fichier. Pas des donnée classique comme le score, mais plus des données qui définissent l'aspect, le comportement et tout un tas de chose pour les objets de mon jeu. (ennemis, bonus, personnages, etc...)

Ici, j'ai besoin de sérialiser ce qui définira le comportement des ennemis.

Pour une raison que je n'étendrais pas, je cherche à sérialiser des structures. =p Bon, structure "presque" classique, la première contient quelques float et int, la deuxième une pair de multimap avec un float pour clé et la première structure pour valeur.

J'écris mon ptit bazar, j'ajoute les lignes utiles à la sérialisation en suivant le tutoriel de boost, j'instancie mon objet, je me fais un fichier, un text_oarchive et j'enregistre. Enfin ça c'est ce que doit faire le code, mais... Ca marche paaaaaaaaaaaaas! :(

Bon sque j'obtiens, c'est un jolie warning à la compilation, et à l'exécution j'ai un plantage lors de la création de mon oarchive.

Le petit truc qui peut fâcher, c'est que j'ai définis 2 fonctions dans ma deuxième structure, mais j'ai également essayer en faisant une classe, ça revient au même. :\

J'utilise boost 1.40 et Visual Studio 2008.

Je vous met le code, toute explication est la bienvenue, ça m'aidera à avancer dans l'utilisation de boost. =p

Command.h : qui définie les actions que peut effectuer mon objet de jeu (pour l'instant, uniquement un control sur la rotation et sur la vitesse de déplacement)

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
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
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
 
namespace Command
{
	struct META_TURN
	{
		// Données
		unsigned int type;
		float modifier_angle;
		float angular_speed;
		int rotation;
		float randomizer;
 
		// La sérialisation
		friend class boost::serialization::access;
		template<class Archive>
		void serialize(Archive & ar, const unsigned int version)
		{
			ar & type;
			ar & modifier_angle;
			ar & angular_speed;
			ar & rotation;
			ar & randomizer;
		}
 
		// Et un ptit constructeur
		META_TURN(
				unsigned int type,
				float modifier_angle,
				float angular_speed,
				int rotation = 0,
				float randomizer = 0
			) :
			type(type),
			modifier_angle(modifier_angle),
			angular_speed(angular_speed),
			rotation(rotation),
			randomizer(randomizer)
			{}
	};
 
	struct META_THROTTLE
	{
		float targeted_speed;
		float acceleration;
		float randomizer;
 
		friend class boost::serialization::access;
		template<class Archive>
		void serialize(Archive & ar, const unsigned int version)
		{
			ar & targeted_speed;
			ar & acceleration;
			ar & randomizer;
		}
 
		META_THROTTLE(
				float targeted_speed,
				float acceleration,
				float randomizer = 0
			) :
			targeted_speed(targeted_speed),
			acceleration(acceleration),
			randomizer(randomizer)
			{}
 
	};
}

IA.h : Ici on y met deux jolie multimap, une pour les rotation, une autre pour les acceleration. La clé désigne l'instant à partir duquel l'action est réalisée.

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
 
 
#include <map>
#include <boost/serialization/map.hpp>
 
#include "Command.h"
 
struct META_IA
{
	// Mes deux multimap
	std::multimap<float, Command::META_TURN> loaded_turn_commands;
	std::multimap<float, Command::META_THROTTLE> loaded_throttle_commands;
 
	// La serialization des multimap
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive & ar, const unsigned int version)
	{
		ar & loaded_turn_commands;
		ar & loaded_throttle_commands;
	}
 
	// Les deux fonctions qui me simplifie un peu l'insertion d'éléments dans mes multimap
	void AddCommand(float time, Command::META_TURN &meta);
	void AddCommand(float time, Command::META_THROTTLE &meta);
};

Le main.cpp : On y créé une META_IA, on la remplit de commandes Turn et Throttle et on essaye de la sauver.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main()
{
	META_IA meta_ia;
	meta_ia.AddCommand(0.5f, Command::META_THROTTLE(0, 0));
	meta_ia.AddCommand(0.8f, Command::META_THROTTLE(200, 0));
	meta_ia.AddCommand(1.f, Command::META_THROTTLE(0, 0));
	meta_ia.AddCommand(1.3f, Command::META_THROTTLE(200, 0));
	meta_ia.AddCommand(1.5f, Command::META_TURN(0, 50, 0, 0, 20));
	meta_ia.AddCommand(1.7f, Command::META_TURN(0, 100, 0, 0, 20));
	meta_ia.AddCommand(1.9f, Command::META_TURN(0, 50, 0, 0, 20));
	meta_ia.AddCommand(2.f, Command::META_THROTTLE(0, 200));
	meta_ia.AddCommand(2.f, Command::META_TURN(0, 50, 100, 1));
	meta_ia.AddCommand(3.5f, Command::META_THROTTLE(400, 400, 300));
	meta_ia.AddCommand(3.5f, Command::META_TURN(1, 180, 170, 1, 10));
 
	// Saving
	{
		std::ofstream ofs("001.mia");
		boost::archive::text_oarchive oa(ofs); // Ca veut paaaaas
		oa << meta_ia;
	}
	return EXIT_SUCCESS;
}

Et ça merdouille à la création de la boost::archive.

Je vous met les warning que j'obtiens à la compilation :

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
1>main.cpp
1>d:\microsoft visual studio 9.0\vc\include\boost\archive\detail\oserializer.hpp(542) : warning C4099: 'boost::serialization::static_warning_impl<false>::STATIC_WARNING' : type name first seen using 'struct' now seen using 'class'
1>        d:\microsoft visual studio 9.0\vc\include\boost\serialization\static_warning.hpp(115) : see declaration of 'boost::serialization::static_warning_impl<false>::STATIC_WARNING'
1>        d:\microsoft visual studio 9.0\vc\include\boost\archive\detail\common_oarchive.hpp(62) : see reference to function template instantiation 'void boost::archive::save<Archive,T>(Archive &,T &)' being compiled
1>        with
1>        [
1>            Archive=boost::archive::text_oarchive,
1>            T=META_IA
1>        ]
1>        d:\microsoft visual studio 9.0\vc\include\boost\archive\basic_text_oarchive.hpp(75) : see reference to function template instantiation 'void boost::archive::detail::common_oarchive<Archive>::save_override<T>(T &,int)' being compiled
1>        with
1>        [
1>            Archive=boost::archive::text_oarchive,
1>            T=META_IA
1>        ]
1>        d:\microsoft visual studio 9.0\vc\include\boost\archive\detail\interface_oarchive.hpp(64) : see reference to function template instantiation 'void boost::archive::basic_text_oarchive<Archive>::save_override<T>(T &,int)' being compiled
1>        with
1>        [
1>            Archive=boost::archive::text_oarchive,
1>            T=META_IA
1>        ]
1>        z:\dev\sfml_test_2\sfml_test_2\main.cpp(44) : see reference to function template instantiation 'Archive &boost::archive::detail::interface_oarchive<Archive>::operator <<<META_IA>(T &)' being compiled
1>        with
1>        [
1>            Archive=boost::archive::text_oarchive,
1>            T=META_IA
1>        ]

Vala, j'ai maté le tutorial sur boost:serialization, j'ai consulter le net, mais pas trouvé de réponse. =)

Donc de retour tout frais après une bonne nuit de sommeil. (Ou pas, foutue nuit froide. :( )

J'ai recherché encore, il parait que le warning n'est pas important, c'est une issue connu de la 1.40...

Par contre, j'ai réessayer, mon bug n'apparait qu'en mode debug. En mode release, ça s'exécute parfaitement. De plus, il n'a rien à voir avec mes structures, il apparait si je fais simplement ça en mode debug :
Code:

1 2 std::ofstream ofs("001.mia"); boost::archive::text_oarchive oa(ofs);
J'ai linké la lib "libboost_serialization-vc90-mt-1_40.lib" à mon projet en debug et release, peut-être ai-je besoin d'une lib à part pour le debug? :\

Lorsque j'exécute, je reçois un message :

Citation:

A buffer overrun has occurred in SFML_test_2.exe which has corrupted the program's internal state. Press Break to debug the program or Continue to terminate the program.

For more details please see Help topic 'How to debug Buffer Overrun Issues'.

Et j'ai un breakpoint à la ligne 298 du fichier "gs_report.c" :
Code:

1 2 3 4 5 #if defined (_CRTBLD) && !defined (_SYSCRT) DebuggerWasPresent = IsDebuggerPresent(); _CRT_DEBUGGER_HOOK(_CRT_DEBUGGER_GSFAILURE); // <--- Breakpoint #endif /* defined (_CRTBLD) && !defined (_SYSCRT) */

Huh ho lol, je fini pas comprendre pourquoi personne ne me répond...

Quelques semaines (mois?) après, j'ai trouvé la raison : j'ai pas link la bonne lib pour le mode debug. Erreur de débutant. :(

En release : libboost_serialization-vc90-mt-1_40.lib
En debug : libboost_serialization-vc90-mt-gd-1_40.lib

Affaire classée. =p