"sicherheitsysteme" für "fileloading" in template-klasse

[krabbels]

hi!
ich will mir eine template-klasse schreiben, die ein array vom typ T in eine datei schreibt.in der klasse ist auch die dazugehörige loadfromfile() methode implementiert, allerdings muss der benutzer darauf achten, dass er beim laden den gleichen typ T verwendet wie beim speichern.
wenn er zb ein template-klasse<float>::array in eine datei speichert, muss er natürlich beim laden dieser datei wieder ein template-klasse<float>::array laden, andernfals ist das ergebnis ziemlich wahrscheinlich fehlerhaft.
fallen euch irgendwelche "sicherheitsysteme" ein, die beim fehlerhaften laden (laden mit anderem typ)zumindest eine fehlermeldung ausgeben?
sollte man sowas generell vermeiden und sich eine andere lösung ausdenken?
ich hoffe ihr könnt mir weiterhelfen

[deformator]

hi,
eine idee in die richtung, die ich selbst verwende, ist das Speichern und Laden über ein und die selbe Funktion zu machen.

Beispiel:

// Eine Beispiel-Klasse die gespeichert bzw geladen werden soll. 
// Die Funktion serialize wird dann entspeichend aufgerufen
class Daten
{
   void serialize(Serializer* s)
   {
      s->process(wert);
   }

 float wert;
};

// Hier sind die Serializer.
struct Serializer
{
   virtual void process(float f) = 0;
};

struct SerLoader : public Serializer
{
   void process(float f)
   {
      // Lade irgendwo
   }
};

struct SerSaver : public Serializer
{
   void process(float f)
   {
      // Speichere irgendwo
   }
};

Hoffentlich ist es verständlicher.

Ich habe mal nach dem Ansatz ein Framework geschrieben. Wenn es jemand will, kann ich es hier posten.

[deformator]

Ich habe noch vergessen zu sagen, wie du es verwenden kannst.

Daten d;
   // irgendwie irgendwo werden die Daten gesetzt.
   SerSaver saver;
   saver.setFile("c:\\meine.datei"); // Natürlich musst du die Funktion selbst implementieren. Ist aber nicht das Problem
   d.serialize(&saver);   

   SerLoader loader;
   loader.setFile("c:\\meine.datei");
   d.serialize(loader);

[CStoll]

Wenn du nu7r die Array-Daten schreibst, gehen die Typ-Informationen unterwegs verloren (die Datei ist nur eine Ansammlung an Bytes - was das Programm dort sieht, interessiert das Betriebssystem nicht), also müsstest du am Anfang der Datei deinen Datentyp schreiben und beim Lesen vergleichen, z.B. über die typeinfo-Struktur.

(wenn du nur eine begranzte Anzahl an eigenen Datentypen verwalten willst, kannst du denen auch eine Kennung als static Member verpassen)

[deformator]

CStoll schrieb:

(wenn du nur eine begranzte Anzahl an eigenen Datentypen verwalten willst, kannst du denen auch eine Kennung als static Member verpassen)

Mit C++ kannst du das viel besser erreichen. Ohne irgendwelche Kennungen. Man muss nur eine Funktion schreiben, die nach entsprechendem Datentyp überladen ist, sowie z.B. die << bzw. >> für die Stream-Verarbeitung.

[Simon2]

Hi,

ich befürchte, das Problem liegt in der "Typunsicherheit von Dateien". Wann immer Du etwas in eine Datei schreibst, kann niemand verhindern, dass jemand dieses Etwas als etwas Anderes rausliest.
Wenn Du über diese Strecke Sicherheit haben willst, musst Du ein "speicherbares Typkonzept überlegen".
Das kann sein:
- simple "Längenüberprüfung beim Laden" oder
- Typkennzeichner mitspeichern und -lesen (was auch keine Konsistenz "erzwingt", aber Fehlererkennung vereinfacht) oder
- eine typsichere Datenbank zur Ablage verwenden.

Wäre übrigens in jeder Sprache dasselbe.

Gruß,

Simon2.

NACHTRAG: Für die "Typkennzeichner-Variante" sollte man ein "allgemeines" Format wie XML in Erwägung ziehen. Die können oft sehr viel und die Einbindung ist oftmals doch viel kürzer als wenn man sich selbst was bastelt.

[krabbels]

danke für die antworten, haben mir sehr geholfen