ich habe eine Frage zu boost. Ich würde gerne eine Object komplett serialisieren, allerdings gibt es Probleme mit dem speichern eines Pointerarrays und den zugehörigen Objekten.
Bis jetzt habe ich in die nötigen Headerdateien:

friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int version) {...}

[...]

BOOST_CLASS_EXPORT_KEY(jeweiliger Klassenname)

ergänzt. Das Problemobjekt ist folgendes:

BF **root = NULL;

soll gespeichert werden, allerdings geht es nicht mit:

void serialize(Archive & ar, const unsigned int version) {
	ar & param;
	ar & insertedFiles;
	ar & queue;
	ar & currInsertLeafPosition;
	ar & *root; // oder ar & root;
}

in der serialize Methode. Auch ein explizites aufrufen der einzelnen Objekte innerhalb des Arrays funktionierte nicht:

void serialize(Archive & ar, const unsigned int version) {
	ar & param;
	ar & insertedFiles;
	ar & queue;
	ar & currInsertLeafPosition;
	// nicht alle Pointer des Arrays zeigen auf ein Objekt
	for (int i = param->getMinBytesToAdress(); i <= param->getMaxBytesToAdress(); i++) {
		ar & boost::serialization::make_array(root[i], param->getMaxBytes());
	}
}

Dieses Beispiel wirft keine Fehlermeldung sondern das Programm wird einfach während des Speichervorgangs beendet (nach dem Speichern ist noch eine Konsolenausgabe, die niemals ausgegeben wird).

Bin für jeden Tipp dankbar

Dieses Beispiel wirft keine Fehlermeldung sondern das Programm wird einfach während des Speichervorgangs beendet

Ich vermute, die "Fehlermeldung" (z.B. eine Exception) ist einfach nicht sichtbar für dich:

Hier ein Vorschlag um sie sichtbar zu machen:

1. Baue dein Programm mit Debug Info
2. Starte das Programm im Debugger
Mehr Fehlerinfo

Ausserdem:

Mach ein vollständiges Minibeispiel, das den Fehler zeigt. So kann dir hier sehr viel effizienter und effektiver geolfen werden.

Hier mal ein wenig wildes Raten:
Fehlt dir ev. BOOST_CLASS_EXPORT_IMPLEMENT ?

Edit: Machst du deine Versuche unter Windows oder unter Linux und mit welchem Compiler/IDE?

Ich entwickel unter Ubuntu in Eclipse "GCC C++ Compiler".

Wenn ich das Programm im Debugmodus laufen lasse, kommt folgender Fehler: 0x00007ffff7bb1765 in boost::archive::basic_binary_oprimitive<boost::archive::binary_oarchive, char, std::char_traits<char> >::save(std::string const&) () from /usr/lib/x86_64-linux-gnu/libboost_serialization.so.1.55.0

Googln gab das Resultat, dass die Bibliotheken nicht richtig gelinkt werden, aber ich habe in meinem Programm, wie auch dem Minimalbsp unter GCC C++ Linker -> Libraries -> Libraries: boost_serialization und unter GCC C++ Compiler -> Inlcudes -> Include paths: /usr/include/boost eingetragen.

Über BOOST_CLASS_EXPORT_IMPLEMENT bin ich auch gestoplert, allerdings habe ich es scheinbar immer an die falsche Stelle geschrieben, so dass das Projekt nicht mehr kompilierte... Es gehört doch in die *.cpp Datei oder? Ich habe es unter den #includes und am ende der Datei versucht

Ist das hilfreich, oder soll ich nochmal am Minimalbsp basteln?

Vielen Dank

Über BOOST_CLASS_EXPORT_IMPLEMENT bin ich auch gestoplert, allerdings habe ich es scheinbar immer an die falsche Stelle geschrieben, so dass das Projekt nicht mehr kompilierte... Es gehört doch in die *.cpp Datei oder?

Korrekt, es gehört in die *.cpp Datei - und zwar müssen davor unbedingt alle Archive includiert werden, welche benutzt werden sollen.

z.B.

MyType.hpp

// Include-Guards + Includes etc.

class MyType
  : public MyBase
{
// ...
public:
  template <typename Archive>
  void serialize(Archive& archive, unsigned int version)
  {
    // ...
  }
};

BOOST_CLASS_EXPORT_KEY(MyType)

MyType.cpp

#include "MyType.hpp"

// Implementation von MyType

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>

BOOST_CLASS_EXPORT_IMPLEMENT(MyType)

Zu exportieren brauchst du die Klasse nur, wenn du über ein Zeiger auf die Basis-Klasse (de-)serialisieren möchtest (deshalb MyBase im Bsp.).

Ist das überhaupt der Fall bei dir?

Norbert987 schrieb:

Ist das hilfreich, oder soll ich nochmal am Minimalbsp basteln?

Hmm... ja, ich würde nochmals versuchen ein Minimal-Bsp. hinzukriegen. Ev. ist es am einfachsten, wenn du dein bestehender Code immer mehr herunter-strippst, bis nur noch das Problem überig ist.

Edit: Versuche doch mal statisch gegen Boost.Serialization zu linken.

Das Speichern funktioniert soweit, solange keine abgeleiteten Klassen gespeichert werden, dass Daten geschrieben werden und keine Exception geworfen wird. Allerdings hängts nun beim Lesen/Schreiben der Daten bei Abgeleiteten Objekten. Die Fehlermeldung lautet:

$1 = 0xff
Die Ziel-Speicherreihenfolge wird automatisch gesetzt (derzeit Little Endian)
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Temporary breakpoint 1, main (argc=1, argv=0x7fffffffded8) at ../Main.cpp:15
15	int main(int argc, char **argv) {

Program received signal SIGSEGV, Segmentation fault.
0x000000000040ea9e in boost::archive::text_oarchive_impl<boost::archive::text_oarchive>::save<unsigned char> (this=0x7fffffffd910, t=@0x0: <error reading variable>) at /usr/include/boost/archive/text_oarchive.hpp:61
61	        basic_text_oprimitive<std::ostream>::save(t);

Program terminated with signal SIGSEGV, Segmentation fault.
The program no longer exists.
Quit

Dies ist ein Minimalbeispiel:

Main.cpp:

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <fstream>
#include <string>

#include "VirtElement.h"
#include "Element.h"

int main(int argc, char **argv) {
	VirtElement *e = new Element;
	e->init(5, 10);

    std::ofstream ofs("/home/tobias/workspace/boost_test/test.dat");
    boost::archive::text_oarchive oa(ofs);
    e->printData();
    oa << e;
    std::cout << "data was written" << std::endl;
    ofs.close();

    VirtElement *e_new = new Element;
    std::cout << "loading data" << std::endl;
    std::ifstream ifs("/home/tobias/workspace/boost_test/test.dat");
    boost::archive::text_iarchive ia(ifs);
    ia >> e_new;
    ofs.close();
    std::cout << "data loaded" << std::endl;

    e_new->printData();

    delete e_new;

	return EXIT_SUCCESS;
}

VirtElement:

#ifndef VIRTELEMENT_H_
#define VIRTELEMENT_H_

#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>

class VirtElement {
public:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive & ar, const unsigned int version) {
        ar & size;
        ar & boost::serialization::make_array(data, size);
	}
	VirtElement();
	virtual ~VirtElement();

	int size;
	unsigned char *data;

	void init(int s, int e);
	void printData();
};

BOOST_CLASS_EXPORT_KEY(VirtElement)

#endif /* VIRTELEMENT_H_ */

// ab híer die VirtElement.cpp
#include "VirtElement.h"

 BOOST_CLASS_EXPORT_IMPLEMENT(VirtElement)

VirtElement::VirtElement() {
	// TODO Auto-generated constructor stub

}

VirtElement::~VirtElement() {
	// TODO Auto-generated destructor stub
}

void VirtElement::init(int s, int e) {

}
void VirtElement::printData() {

}

Und Elementklasse:

#ifndef ELEMENT_H_
#define ELEMENT_H_

#include <boost/serialization/export.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/base_object.hpp>
#include <iostream>

#include "VirtElement.h"

class Element : public VirtElement {
private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive & ar, const unsigned int version) {
		ar & boost::serialization::base_object<VirtElement>(*this);
	}

public:
	Element();
	virtual ~Element();

	void setData(unsigned char *d);
	unsigned char *getData();
	void init(int s, int e);
	void printData();
};

BOOST_CLASS_EXPORT_KEY(Element)

#endif /* ELEMENT_H_ */

// ab hier die Element.cpp
#include "Element.h"

 BOOST_CLASS_EXPORT_IMPLEMENT(Element)

Element::Element() {
	size = -1;
	data = 0;
}

Element::~Element() {
	if (data != 0)
		delete []data;
}

void Element::setData(unsigned char *d) {
	data = d;
}

unsigned char *Element::getData() {
	return data;
}

void Element::printData() {
	std::cout << "write size: " << size << std::endl;
	for (int i = 0; i < size; i++) {
		std::cout << data[i];
	}
	std::cout << std::endl;
}
void Element::init(int s, int e) {
	size = s;
	data = new unsigned char [s];
	for (int i = 0; i < size; i++) {
		data[i] = 'a' + e;
	}
}

Die Idee ist eigentlich, beliebige Klassen von der VirtElement abzuleiten und diese dann einfach austauschen zu können. So kann ich in der Main in Zeile 19 und 29

Element *e = new Element;

schreiben, allerdings verfehlt das den Grund der Ableitung. Dann funktioniert das Speichern, aber beim Laden kommt folgender Fehler:

$1 = 0xff
Die Ziel-Speicherreihenfolge wird automatisch gesetzt (derzeit Little Endian)
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Temporary breakpoint 1, main (argc=1, argv=0x7fffffffde98) at ../Main.cpp:15
15	int main(int argc, char **argv) {

Program received signal SIGSEGV, Segmentation fault.
0x000000000040ed0e in boost::archive::basic_text_iprimitive<std::istream>::load (this=0x7fffffffd940, t=@0x0: <error reading variable>) at /usr/include/boost/archive/basic_text_iprimitive.hpp:114
114	        t = i;

Program terminated with signal SIGSEGV, Segmentation fault.
The program no longer exists.
Quit

Das leere Methoden in der VirtElement.cpp erzeugt werden müssen scheint mir unschön, allerdings wollte der Compiler keine virtuelle Methode ohne Rumpf akzeptieren...

Hast du dazu noch eine Idee? Vielen Dank im Voraus

Edit (2):

• VirtElement::data kannst zwar mit boost::serialization::make_array(..) serialisiert werden, allerdings nicht so einfach wieder deserialisiert werden - bzw. nicht direkt, denn mit ...::make_array(..) wird laut Dokumentation kein Speicher alloziert, was hier ja nötig wäre. Vermutlich könnte man VirtElement::serialize(..) in save(..) / load(..) aufteilen und beim Laden den entsprechenden Speicher für VirtElement::data anfordern, allerdings würde ich gerade auf die Variante mit dem std::vector<unsigned char> umstellen. Das ist weniger fehleranfällig, kürzer und verträgt sich erst noch mit Exceptions.

Orginal:
Einerseits, denke ich, solltest du dich mit C++ Grundlagen befassen.

Hier nur ein paar Hinweise dazu:

• Element::init(..) darf es nicht geben, das gehört in den Konstructor
• delete und delete[] ist gültig für 0 / nullptr , d.h. vorher auf 0 / nullptr zu prüfen ist nicht nötig (und schlechter Stil)
  - Fehlendes delete zu e
  - Generell RAII benutzen
  -- std::ofstream
  -- std::ifstream
  -- Anstelle unsigned char* / new[] / delete[] einfach std::vector<unsigned char> verwenden (Boost.Serialization kann std::vector<..> serialisieren)
  - ...

Aber zu deinem konkreten Problem:

Norbert987 schrieb:

So kann ich in der Main in Zeile 19 und 29

Element *e = new Element;

schreiben, allerdings verfehlt das den Grund der Ableitung. Dann funktioniert das Speichern, aber beim Laden kommt folgender Fehler:

Ich verstehe zwar nicht ganz was du damit sagen möchtest, aber in Zeile 26 (Main.cpp) darfst du natürlich kein neues Objekt erzeugen, das macht dann Boost.Serialization für dich.

VirtElement *e_new = nullptr; // falls dein Compiler kein C++11 unterstützt, einfach 0
std::cout << "loading data" << std::endl;
std::ifstream ifs("/home/tobias/workspace/boost_test/test.dat");
boost::archive::text_iarchive ia(ifs);
ia >> e_new;
ofs.close();
std::cout << "data loaded" << std::endl;

e_new->printData();

delete e_new;

Obs nun besser läuft bezweifle ich allerdings...

Ich würde dir empfehlen, zuerst alle Member-Variablen aus VirtElement und Element herauszunehmen, und nach und nach wieder einzubauen. Ich würde sogar gerade auf std::vector<unsigned char> umstellen.