Boost.Serialization Problem mit kleinem Programm zum Einstieg



  • Guten Tag,
    ich hab ein Problem mit einem einfachem Programm, welches als herantast-Projekt zu boost.serialization entstanden ist. Noch signifikanter: die Fehlermeldung bezieht sich auf eine Codestelle in den boost-headern, und nur da.

    das ganze wurde mit NetBeans und Boost 1.34.1 erstellt, g++-4.2
    Compilermeldung

    Running "/usr/bin/make -f Makefile CONF=Debug" in /media/disk/Serialization_boost

    /usr/bin/make -f nbproject/Makefile-Debug.mk SUBPROJECTS= .build-conf
    make[1]: Betrete Verzeichnis '/media/disk/Serialization_boost'
    /usr/bin/make -f nbproject/Makefile-Debug.mk dist/Debug/GNU-Linux-x86/serialization_boost
    make[2]: Betrete Verzeichnis '/media/disk/Serialization_boost'
    mkdir -p build/Debug/GNU-Linux-x86
    rm -f build/Debug/GNU-Linux-x86/person.o.d
    g++ -c -g -MMD -MP -MF build/Debug/GNU-Linux-x86/person.o.d -o build/Debug/GNU-Linux-x86/person.o person.cpp
    mkdir -p build/Debug/GNU-Linux-x86
    rm -f build/Debug/GNU-Linux-x86/main.o.d
    g++ -c -g -MMD -MP -MF build/Debug/GNU-Linux-x86/main.o.d -o build/Debug/GNU-Linux-x86/main.o main.cpp
    /usr/include/boost/archive/detail/oserializer.hpp: In function »void boost::archive::save(Archive&, T&) [with Archive = boost::archive::text_oarchive, T = Person]«:
    /usr/include/boost/archive/detail/common_oarchive.hpp:62: instantiated from »void boost::archive::detail::common_oarchive<Archive>::save_override(T&, int) [with T = Person, Archive = boost::archive::text_oarchive]«
    /usr/include/boost/archive/basic_text_oarchive.hpp:75: instantiated from »void boost::archive::basic_text_oarchive<Archive>::save_override(T&, int) [with T = Person, Archive = boost::archive::text_oarchive]«
    /usr/include/boost/archive/detail/interface_oarchive.hpp:79: instantiated from »Archive& boost::archive::detail::interface_oarchive<Archive>::operator<<(T&) [with T = Person, Archive = boost::archive::text_oarchive]«
    main.cpp:31: instantiated from here
    /usr/include/boost/archive/detail/oserializer.hpp:566: Fehler: Ungültige Anwendung von »sizeof« auf unvollständigen Typen »boost::STATIC_ASSERTION_FAILURE<false>«
    make[2]: *** [build/Debug/GNU-Linux-x86/main.o] Fehler 1
    make[2]: Verlasse Verzeichnis '/media/disk/Serialization_boost'
    make[1]: *** [.build-conf] Fehler 2

    Die Headerdatei sieht so aus:

    #ifndef _PERSON_H
    #define	_PERSON_H
    
    #include <boost/serialization/string.hpp>
    #include <boost/serialization/vector.hpp>
    
    using std::string;
    using std::vector;
    
    #include <boost/archive/text_iarchive.hpp>
    #include <boost/archive/text_oarchive.hpp>
    
    class Person {
    private:
        //Teil von Boost
        friend class boost::serialization::access;
        //Serialisierungsfunktion Boost::Serialization
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version);
    public:
        Person(){}
        Person(std::string nachname, std::string vorname);
        Person(const Person& orig);
        virtual ~Person();
    
        void add_geschwister(const Person& name);
        void show_geschwister() const;
    
        string getVorname() const { return vorname; }
        string getNachname() const { return nachname; }
    private:
        string vorname;
        string nachname;
        vector<Person> geschwister;
    };
    
    #endif	/* _PERSON_H */
    

    Die Implementierungsdatei sieht so aus:

    #include <iostream>
    
    #include "person.h"
    
    Person::Person(std::string n, std::string v):
        vorname(v), nachname(n){
    }
    
    Person::Person(const Person& orig) {
        nachname = orig.nachname;
        vorname = orig.vorname;
        geschwister = orig.geschwister;
    }
    
    Person::~Person() {
    }
    
    //Boost::Serialisation
    template<class Archive>
    void Person::serialize(Archive& ar, const unsigned int version)
    {
        ar & vorname;
        ar & nachname;
        ar & geschwister;
    }
    
    void Person::add_geschwister(const Person& person)
    {
        geschwister.push_back(person);
    }
    
    void Person::show_geschwister() const
    {
        for(vector<Person>::const_iterator iter = geschwister.begin();
            iter != geschwister.end(); iter++)
        {
            std::cout << iter->getVorname() << std::endl;
        }
    }
    

    und die main.cpp so:

    #include <iostream>
    //#include <string>
    #include "person.h"
    
    #include <fstream>
    #include <boost/archive/text_iarchive.hpp>
    #include <boost/archive/text_oarchive.hpp>
    
    /*
     * 
     */
    int main(int argc, char** argv) {
    
        Person peter("Peter","Silie");
        Person a("Anna", "Nass");
        Person b("Tom", "Bola");
        peter.add_geschwister(a);
        peter.add_geschwister(b);
    
        {
            std::ofstream ofs("speicher.bin");
    
            boost::archive::text_oarchive oa(ofs);
            oa << peter;
        }
    
        Person newPeter;
        std::ifstream ifs("speicher.bin");
        boost::archive::text_iarchive ia(ifs);
    
        ia >> newPeter;
    
        newPeter.show_geschwister();
    
        return 0;
    }
    

    Im Internet habe ich leider nichts finden können, was zu der Fehlermeldung passt.



  • ein STATIC_ASSERT schlägt fehl, das heißt dass dein code eine notwendige bedingung nicht erfüllt, die bereits während des kompilierens geprüft wird.

    ich kenne mich mit boost nicht genug aus um das problem zu lokalisieren, aber ich rate einfach mal, dass deine klasse 'Person' nicht alle anforderungen erfüllt, um mit boost::serialization zu funktionieren.



  • hi,

    ein seriallizer bietet ja die möglichkeit ein object als bitstream über zb RS232 zu übertraggen? soweit ich weiss auch platform unabhängig. gibt es dafür sowas wie seriallizer protokolle? kann könnte ja auf einer seite java und auf der anderen seite c++ haben?

    lg



  • hu?



  • ist man als user in der lage eines nach der serialisierung gelieferte xml format zu verstehen?



  • also das erste was mir auffällt:

    die Serialisierungsmethode ist ein template, die du erst in der cpp definierst, das haut bei templates nicht hin! Du musst die Methode direkt im Header definieren.

    Versuch das bitte und teil uns mit, ob es dann funktionert 😉



  • cpp1 schrieb:

    ist man als user in der lage eines nach der serialisierung gelieferte xml format zu verstehen?

    ist schon länger her, aber wenn ich es richtig in Erinnerung habe, dann schon!



  • cpp1 schrieb:

    hi,

    ein seriallizer bietet ja die möglichkeit ein object als bitstream über zb RS232 zu übertraggen? soweit ich weiss auch platform unabhängig. gibt es dafür sowas wie seriallizer protokolle? kann könnte ja auf einer seite java und auf der anderen seite c++ haben?

    lg

    für diese zwecke würde ich dann eher auf middleware ansätze, wie CORBA oder besser gleich ICE. Web-Services (via SOAP) sind auch denkbar. Das Problem ist hier, dass der bitstream immer gleich interpretiert werden muss und die Klassen in unterschiedlichen Sprachen und Plattformen anders abgebildet werden. Hier helfen IDL-Beschreibungen weiter...



  • CORBA ist eher nicht geeignet.

    ziel ist es in meinem projekt die gui und verarbeitung zu trennen. ohne gui möchte ich über die xml auch in der lage sein die weiteren schritte zu realisieren...

    die gui soll eine xml datei erzeugen und der input der verabeitung sein...
    der user soll auch in der lage sein eine eigene xml datei zu erstellen usw...

    da ist serialization das falsche thema?

    bye



  • ich könnte statt der gui eine command line appl. draus machen...



  • cpp1 schrieb:

    da ist serialization das falsche thema?

    kommt darauf an, wie komplex das ganze ist. wenn du datenströme zwischen C++ Apps austauscht, sind Datenströme mit serialsierten Strömen das eifnachste und sicherste... Allerdings wirst du damit Probleme bekommen, wenn du zwischen zwei Sprachen oder Platformen Daten austauscht, es sei denn du erweiterst deine Klassen um eigene IDL Methoden...



  • ich habe auch vor die gui mit python zu machen und den rest mit c++

    also keine serialisierung, stattdessen ein ganz normaler xml parser nehmen?



  • hu?


Log in to reply