JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=81d24c24ed123ed94a98d93c9730da8dMedaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

Serializieren von vererbten Klassen

 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Entwicklung
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Otscho
Super JLI'ler


Alter: 35
Anmeldedatum: 31.08.2006
Beiträge: 338
Wohnort: Gummibären-Gasse
Medaillen: Keine

BeitragVerfasst am: 28.04.2009, 09:01    Titel: Serializieren von vererbten Klassen Antworten mit Zitat

Hallo !

Ich habe eine std::list die mir Zeiger auf Instanzen unterschiedlicher Klassen aber mit selben Basisklasse.

Jetzt möchte ich bestimmte Elemente dieser Klasse in einen Bytestream, oder auch boost::archive, serializieren um sie auf verschiedenen Geräten zu speichern.

Dazu verwende ich die boost library. Alle Klassen sind so präperiert, wie es in der doku steht. (http://www.boost.org/doc/libs/1_38_0/libs/serialization/doc/index.html)

Allerdings wird hierbei zur Laufzeit eine Exception von boost ausgelöst.

Beim Debuggen kam ich zur einer Stelle, an der Folgendes in den Kommentaren steht:
Zitat:
Zitat:
// if your program traps here, it indicates that your doing one of the following:
// a) serializing an object of a type marked "track_never" through a pointer.
// b) saving an non-const object of a type not markd "track_never)
// Either of these conditions may be an indicator of an error usage of the
// serialization library and should be double checked. See documentation on
// object tracking. Also, see the "rationale" section of the documenation
// for motivation for this checking.


Leider sagt mir das recht wenig.


Kann mir da jemand weiterhelfen ?
Die Serializaion ist noch Neuland für mich und es kann sein, dass ich da einen völligen Holzweg gegangen bin.

Ich freue mich über jede hilfreiche Antwort.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
DirectXer
Dark JLI'ler



Anmeldedatum: 05.02.2005
Beiträge: 1201
Wohnort: Köln
Medaillen: Keine

BeitragVerfasst am: 29.04.2009, 17:52    Titel: Antworten mit Zitat

hi,

am besten zeigst du mal ein bisschen code, z.b. wie du deine benutzung von boost serialization implementierst. Auch die Klassendefinitionen wären hilfreicht.

Was ich mir spontan vorstellen könnte ist dass du irgendwo einen Zeiger / eine Referenz überträgst die nicht const ist (d.h. die du an einem punkt im programm verändern darfst wo dies nicht erlaubt ist, wahrscheinlich aus gründen der fehleranfälligkeit). Trotzdem mit mehr code kann man immer präziser helfen Wink

Gruß DXer
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
Otscho
Super JLI'ler


Alter: 35
Anmeldedatum: 31.08.2006
Beiträge: 338
Wohnort: Gummibären-Gasse
Medaillen: Keine

BeitragVerfasst am: 30.04.2009, 08:43    Titel: Antworten mit Zitat

Die definition meiner Basisklasse:
CPP:
class BaseObject{
   friend class boost::serialization::access;

public:

   dllexp BaseObject() {}
   dllexp ~BaseObject() {}

   dllexp virtual BaseMetaInfo* GetMetaInfoPtr() {return NULL; }

   template<class Archive>
    dllexp void serialize(Archive & ar, const unsigned int version)
    {

    }
};


Die wird geerbt von einer weiteren Klasse:
CPP:
class Basic_3DObject : public BaseObject
{
   friend class boost::serialization::access;

protected:

   float m_fSelection;

public:

   Matrix m_Matrix;
   wstring m_Name;

   dllexp Basic_3DObject(void);
   dllexp virtual ~Basic_3DObject(void);

   template<class Archive>
   dllexp void serialize(Archive & ar, const unsigned int version)
       {
      ar & boost::serialization::base_object<BaseObject>(*this);
        ar & m_Matrix;
      //ar &    m_Name;                                             //       Linkerfehler !!!!!!!!
    }

   [Zugriffsfunktionen]
      ...
};



Bis dahin funktioniert die serialization noch.

Jetzt hab ich aber noch von Basic_3DObject abgeleitete Klassen, die mithilfe einer Classfactory instanziert werden. Und genau diese möchte ich serializieren.

Diese Instanzen speichere ich in einer Map, besser gesagt die Zeiger der Instanzen (map<std::wstring, Basic_3DObject*>).

Die Serialization sieht dann wie folgt aus:
CPP:
std::ofstream ofs(filename.c_str());

   boost::archive::text_oarchive oa(ofs);

   map<std::wstring, Basic_3DObject*>::iterator itObj;
   for(itObj = pObjectManager->m_ObjectMap.begin(); itObj != pObjectManager->m_ObjectMap.end(); itObj++) {
      Basic_3DObject* pObject = itObj->second;
      oa << pObject;
   }

Habe nur zum Debuggen mal den Zeiger nochmal in ne Variable kopiert.

Beim Kompilieren bekomme ich auch eine etwas umfahgreichere Warnung, die mir ihre Information nicht wirklich offenbaren will:

Zitat:
1>d:\sdk\boost_1_38\boost\archive\detail\oserializer.hpp(538) : warning C4099: 'boost::serialization::static_warning_impl<false>::STATIC_WARNING': Geben Sie den zuerst unter Verwendung von 'struct' und jetzt unter Verwendung von 'class' gesehenen Namen ein
1> d:\sdk\boost_1_38\boost\serialization\static_warning.hpp(115): Siehe Deklaration von 'boost::serialization::static_warning_impl<false>::STATIC_WARNING'
1> d:\sdk\boost_1_38\boost\archive\detail\common_oarchive.hpp(64): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void boost::archive::save<Archive,T>(Archive &,T &)".
1> with
1> [
1> Archive=boost::archive::text_oarchive,
1> T=const Basic_3DObject *
1> ]
1> d:\sdk\boost_1_38\boost\archive\basic_text_oarchive.hpp(75): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void boost::archive::detail::common_oarchive<Archive>::save_override<T>(T &,int)".
1> with
1> [
1> Archive=boost::archive::text_oarchive,
1> T=const Basic_3DObject *
1> ]
1> d:\sdk\boost_1_38\boost\archive\detail\interface_oarchive.hpp(64): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "void boost::archive::basic_text_oarchive<Archive>::save_override<T>(T &,int)".
1> with
1> [
1> Archive=boost::archive::text_oarchive,
1> T=const Basic_3DObject *
1> ]
1> d:\projekte\meliobasic\serializer\binaryserializer.cpp(27): Siehe Verweis auf die Instanziierung der gerade kompilierten Funktions-template "Archive &boost::archive::detail::interface_oarchive<Archive>::operator <<<const Basic_3DObject*>(T &)".
1> with
1> [
1> Archive=boost::archive::text_oarchive,
1> T=const Basic_3DObject *
1> ]
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
Otscho
Super JLI'ler


Alter: 35
Anmeldedatum: 31.08.2006
Beiträge: 338
Wohnort: Gummibären-Gasse
Medaillen: Keine

BeitragVerfasst am: 02.05.2009, 15:24    Titel: Antworten mit Zitat

Der Hinweis von DirectXer hat leider nicht geholfen, aber trotzdem Danke.

Weiß keiner Rat ?

Wie serializiert ihr denn ?

Evt. gibts ja noch bessere Varianten.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Entwicklung Alle Zeiten sind GMT
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum