Speichern eines Vektors in eine Datei

Roadda

Ich habe zu dem Thema in den FAQ ein Beispiel gefunden. Dieses erfüllt aber nicht meine Ansprüche, da dort nur ein Datensatz pro Vektoreintrag gespeichert wird.
Auf meinem Vektor liegen aber pro Vektoreintrag 3 Datensätze.

Also wie kann ich 3 Datensätze speichern?
Vielen Dank schon mal...

Hier mal das Bsp aus den FAQ:

#include <vector>
#include <iostream>
#include <iterator>
#include <fstream>
#include <vector>

using namespace std;

int main()
{
    vector<int> myVec;
    myVec.reserve(100);
    // Sinnloses befüllen des Vectors, hauptsache da is was drin
    for(int i = 0;i < 100;++i)
        myVec.push_back(i);

    fstream datei("Ausgabe.txt", ios::out);
    if(!datei)
        return 20;

    // Speichern
    datei<<myVec.size()<<" "; // Optional

    // Das ist das ganze Speichern. Bei Fragen fragen
    copy(myVec.begin(),myVec.end(),ostream_iterator<int>(datei," "));

    datei.close(); // Datei schliessen (wollen ja wieder draus lesen)

    // Lesen
    datei.open("Ausgabe.txt",ios::in);
    if(!datei)
        return 20;

    myVec.clear();     // Vector leer machen, sonst heisst es noch ich les nix das
                    // stand da ja schon :clown:

    vector<int>::size_type size; //Optional
    datei>>size; //Optional
    myVec.reserve(size); //Optional

    istream_iterator<int> begin(datei); // Anfangsiterator auf die Datei
    istream_iterator<int> end; // Enditerator
    copy(begin,end,back_inserter(myVec)); // Und wieder auslesen.
    // Kontrollausgabe ob das auch geht
    copy(myVec.begin(),myVec.end(),ostream_iterator<int>(cout," "));
    return 0;
}

GPC

Roadda schrieb:

Ich habe zu dem Thema in den FAQ ein Beispiel gefunden. Dieses erfüllt aber nicht meine Ansprüche, da dort nur ein Datensatz pro Vektoreintrag gespeichert wird.
Auf meinem Vektor liegen aber pro Vektoreintrag 3 Datensätze.

Also wie kann ich 3 Datensätze speichern?

Ich nehme an, die Datensätze liegen in einem struct vor?
Dann schreib doch einfach ne Serialisierungsmethode, die du dann für jedes Vektorelement aufrufst.

MfG

GPC

Roadda

Die Datensätze liegen in einem enum...

Was ist eine Serialisierungsmethode?

GPC

Roadda schrieb:

Die Datensätze liegen in einem enum...

na ja, auch wurscht. Dann machen wir halt ne Funktion draus:

//Dein Enum
enum Values { A, B, C };

//Die Funktion
void serialize(std::ofstream &ofs, Values v) {
  short repr = static_cast<short>(v.A);
  ofs.write(reinterpret_cast<char*>(&repr), sizeof(repr));

  repr = static_cast<short>(v.B);
  ofs.write(reinterpret_cast<char*>(&repr), sizeof(repr));

  repr = static_cast<short>(v.C);
  ofs.write(reinterpret_cast<char*>(&repr), sizeof(repr));
};

Values deserialize(std::ifstream &ifs) {
  Values v;
  short repr;
  ifs.read(reinterpret_cast<char*>(&repr), sizeof(repr));
  v.A = static_cast<Values>(repr);

  ifs.read(reinterpret_cast<char*>(&repr), sizeof(repr));
  v.B = static_cast<Values>(repr);

  ifs.read(reinterpret_cast<char*>(&repr), sizeof(repr));
  v.C = static_cast<Values>(repr);

  return v;
};

MfG

GPC

CStoll

What'n für ein enum? Vielleicht wäre es doch günstig, mal ein Beispiel für DEIN Problem zu zeigen. Mit einem enum kannst du (fast) genauso umgehen wie mit int-Werten.

(@Serialisierung: Du benötigst eigentlich nur die Streaming-Operatoren "ostream& operator<<(ostream& f, const myType& d);" und "istream& operator>>(istream& f, myType& d);" für deinen Datentyp, dann kannst du deinen Beispielcode analog zu oben einsetzen).

Roadda

Mein Problem: Ich erstelle mit FLTK einen Dialog, der mit verschiedenen Testarten arbeitet. Diese Testarten enthalten 3 Daten: Testname, Pfad und Größe.
Wenn ich jetzt auf meinen Vektor Testarten lege, will ich diese speichern und dazu muss ich ja dem Vektor klar machen, dass der eine String, den die Funktion einließt, dann in drei Teilstrings umwandelt wird.

QGPC: Danke für die Mühe, aber wie binde ich das denn jetzt in mein Programm ein bzw. wie sieht dann meine speichern-funktion aus?

Meine Funktion:

void Arbeitsfenster::speichern() {
     ofstream ausgabedatei("Ausgabe.txt");
     if(ausgabedatei) {
     ostream_iterator<int>out(ausgabedatei, "*");
     copy(tests.begin(), tests.end(), out);
     message("Gespeichert.");
     }
     ausgabedatei.close();
}

CStoll

Die Stream-Operatoren können das fast von alleine:

struct Daten
{
  string Name, Pfad;
  int Groesse;
};

ostream& operator<<(ostream& f,const Daten& d)
{
  f<<d.Name<<"-"<<d.Pfad<<"-"<<d.Groesse;
  return f;
}

istream operator>>(istream& f,Daten& d)
{
  getline(f,d.Name,'-');
  getline(f,d.Pfad,'-');
  f>>d.Groesse;
  //Eventuell Fehlerkontrolle
  return f;
}

(In dem Datensatz dient das Minus als Trennzeichen - du mußt nur darauf achten, daß es nicht als Teil des Namens und Pfads vorkommt)

Roadda

Tschuldigung, meine Datensätze sind nicht in einem enum, sondern in der folgenden Klassen gespeichert:

enum Testart {
    fileExists, fileReadable, fileLength, directoryExists, directoryExecutable, 
    spaceSufficient, environmentVariable, commandOutput
};

class Test {
      public:
             Test(Testart ta = fileExists, const std::string to = "", const std::string tp = "")
             :testart_(ta), testobjekt_(to), testparameter_(tp){}
             virtual ~Test(){}
             Testart testart() const {
                  return testart_;
             }
             void testart(Testart t) {
                  testart_ = t;
             }
             const std::string& testobjekt() const {
                   return testobjekt_;
             }
             void testobjekt(const std::string to) {
                  testobjekt_ = to;
             }
             const std::string& testparameter() const {
                   return testparameter_;
             }
             void testparameter(const std::string tp) {
                  testparameter_ = tp;
             }
      private:
              Testart testart_;
              std::string testobjekt_, testparameter_;
};

Mein Fehler!

@Stoll: Danke für den Text!