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.

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.

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

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

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!

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...

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

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...

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