Serialisierung in C

Hi,

Ich programmiere derzeit eine kleine Spieleengine. Da gibt es natürlich auch einen Scene graph. Der besteht aus jeder menge verlinkter structs. Im Prinzip ist es ein Baum, bei dem jeder Knoten beliebig viele Wurzeln haben kann (gelöst mit eldest child + siblings). Jeder Knoten enthält sowohl simple datentypen als auch wieder andere structs, die das Objekt beschreiben. Außerdem sin auch funktionspointer mit in der Struktur.
Wie bekomme ich zum Serialisieren alles unter einen Hut, sodass ich den ganzen Baum speichern kann und später auch wieder laden? Gibt es tutorials die ihr mir empfehlen könnt?

Danke,
CStarter

Du musst alle zur Speicherung erforderlichen Daten abrufen können.
Wie würdest du denn diese Struktur speichern:

struct
{
    char* data; // 0 - 4GB Datenspeicher, dynamisch allokiert.
};

@Schlaumayer
dein argument hat einen hacken: wer programme schreibt, bei denen er nicht herausfinden kannst, wie groß die daten sind, hat sowieso einen bug. der threadersteller hat ja nicht nach einer methode gefragt, die c von selbst kann.

@CStarter
ich gehe, davon aus, dass jede struktur gleich groß ist. am besten beginnst du damit, die header daten des baums (die anzahl an knoten vor allem) in die datei zu schreiben. danach folgt ein array aus den serialisierten knoten. damit die verbindungen zw. den knoten nicht untergehen, musst du diese in der serialisierten form der knoten speichern. dazu musst du jeden serialisierten knoten innerhalb des arrays identifizieren. das klappt am besten mit einem index. der erste knoten ist 0 und so weiter. die adressen kannst du nicht direkt speichern.
bedenke aber bei allem auch, wie du plattformunabhängigkeit erreichen kannst bezüglich größe von datentypen und endianess.

serialisierer schrieb:

@Schlaumayer
dein argument hat einen hacken: wer programme schreibt, bei denen er nicht herausfinden kannst, wie groß die daten sind, hat sowieso einen bug. der threadersteller hat ja nicht nach einer methode gefragt, die c von selbst kann.

Wenn ein Programm nicht dafür vorgesehen ist Zustände zu speichern, bzw. diese nicht gespeichert werden müssen, so ist dies keineswegs ein Bug.

Da ja serialisierer sein Programm scheibar komplett selbst schreibt, kann er ja die zum Speichern nötigen Strukturen von vornherein geeignet gestalten.

struct xyz
{
    char* data; // 0 - 4GB Datenspeicher, dynamisch allokiert.
    unsigned bytes; // Anzahl der Bytes von data

};

Das mit den Indices löst vermutlich das Problem der Beziehungen zwischen struct instanzen, aber wie mache ich das mit Funktionspointern? kann ja schlecht für jede Funktion eine ID vergeben. Dann bräuchte ich ja ein Mapping zwischen ID un Funktion. Ich würde aber ungern ein solches mapping struct bauen. Das müsste ich nämlich jedes mal ergänzen, wenn eine neue Funktion hinzukommt.

Mein anderes Problem ist: ich weiß am Anfang nicht, welche structs nachher alle serialisiert werden. Ich bräuchte also einen allgemeinen Ansatz. Der Grund dafür liegt daran, dass im Scene graph sehr viele unterschiedliche Elemente sind. Und mit der Zeit wächst die Vielfalt natürlich nur weiter an. Also suche ich eigentlich nach einer Möglichkeit beliebige Structs zu serialisiern. Mit einem schlauen workaround wäre ich auch zufrieden.

herauszufinden wie groß die structs sind ist übrigens kein Problem, solange ich weiß um welchen struct-typ es sich handelt.

Danke schonmal,
CStarter

struct MyStruct
{
    bool serialize;
// ... data
};

int serialize( struct MyStruct* p, int n )
{
    for ( i=0; i<n; i++ )
    {
        if( p[i]->serialize )
        {
            MyStoreFunc( p[i]->serialize );
        }    
    }
}

@Schlaumayer
ein programm muss immer wissen, wieviele daten es hat. wie soll es daten verarbeiten, wenn es nicht weiß, wieviele es sind? das is einfach unmöglich. sorry.

@CStarter
Funktionspointern haben auch nichts mir serialisierung zu tun. das ist eher kompliziert, diese zu speichern. du wirst um eine art id sache nicht herumkommen. die adressen selbst du hier ebenso wenig speichern.

BorisDieKlinge

man könnte das serialiserungsobjet immer wieder dynamisch vergrößeren und struct für struct anhängen, dann ist es nich unbedingt nowendig, das man vorher schon weis wie groß die daten sind