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;
}

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

Was ist eine Serialisierungsmethode?

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

(@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).

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();
}

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)

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!