mit seekp () ist es ja möglich, den Offset der Datei anzugeben. Ich möchte jedoch die Zeilennummer angeben können, oder anders formuliert, der Schreib/Lesezeiger soll auf den Anfang einer Zeile zeigen, die ich angegeben habe. Wie ist das möglich? Danke!

struct test
    {
        std::string name;
        std::string nachname;
        std::string email;
    };

    test k1;

    std::cout << "k1: " << sizeof (k1) << std::endl;

    k1.name = "Hans";
    k1.nachname = "Wurscht";
    k1.email = "hans.wurscht.frenenet.de";
    std::cout << "k1 initialisiert: " << sizeof (k1) << std::endl;

    std::ofstream out ("C://struct.txt", std::ios::binary);
    out.write (reinterpret_cast <char*> (&k1), sizeof (test));
    out.close ();

    std::ifstream in ("C://struct.txt", std::ios::binary);
    test k2;
    in.read (reinterpret_cast <char*> (&k2), sizeof (k1));
    std::cout << k2.name;
    std::cout << k2.nachname;
    std::cin.get ();

Danke Leute!

was gibt er dir aus?

PS: Übrigens ist es sehr gefährlich, auf Byte-Ebene mit nicht-PODs zu hantieren - damit zerstörst du möglicherweise die internen Verwaltungsstrukturen der Objekte. Da wundert es mich wirklich, daß dein Code dort oben keine SegFaults prozuziert.

Da wundert es mich wirklich, daß dein Code dort oben keine SegFaults prozuziert.

Mich nicht, er liest doch Zeiger wieder ein, die noch gültig (da noch in Scope) sind: Es wird test2 eingelesen. Dabei ist das, was eingelesen wird, natürlich Datenmüll. Aber dieser Datenmüll ist zufällig gültig, weil test1 noch existiert. Von daher ist kein Wunder, dass dieser spezielle Code „funktioniert“. Das, was der OP will, tut er natürlich trotzdem nicht.

@CodeOriginator: Der Code ist, wie Du vielleicht schon entnommen hast, Müll. Dein Vorhaben klappt so nicht. Du musst für Deine Struktur einen spezifischen Ausgabe-Operator schreiben. Der Cast auf char* bringt nicht das, was Du Dir erwartest (sowas klappt nur mit POD).

CStoll schrieb:

Da wundert es mich wirklich, daß dein Code dort oben keine SegFaults prozuziert.

Mich nicht, er liest doch Zeiger wieder ein, die noch gültig (da noch in Scope) sind: Es wird test2 eingelesen. Dabei ist das, was eingelesen wird, natürlich Datenmüll. Aber dieser Datenmüll ist zufällig gültig, weil test1 noch existiert. Von daher ist kein Wunder, dass dieser spezielle Code „funktioniert“. Das, was der OP will, tut er natürlich trotzdem nicht.

Daß das Einlesen hier zufällig klappt, kann ich durchaus verstehen, aber danach hätte ich einen SegFault erwartet, weil beide Objekte versuchen, diesen Speicher wieder freizugeben (double delete).

Daß das Einlesen hier zufällig klappt, kann ich durchaus verstehen, aber danach hätte ich einen SegFault erwartet, weil beide Objekte versuchen, diesen Speicher wieder freizugeben (double delete).

Ja, da haste auch wieder recht.

Könnt ihr mir bitte erklären, was PODs sind, und wie ich es besser machen kann? Danke im Voraus!

Für dein Problem solltest du der Klasse einen eigenen operator<< (und operator>>) spendieren, der die Aus- und Eingabe übernimmt - die können auf die IO-Operatoren zurückgreifen, wenn du willst.

#include <iostream>
using namespace std;

typedef unsigned char My32BitInteger[4];

class MyInteger
{
    private:
        My32BitInteger myInt;

    public:
        // Konvertierungsoperator
      operator int();
    // Standardkonstruktor
    MyInteger()
    {
        cout << "Standardkonstruktor" << endl;
        myInt[0] = 0;
        myInt[1] = 0;
        myInt[2] = 0;
        myInt[3] = 0;
    }

    // Konvertierungskonstruktor
    MyInteger( int i )
    {
        cout << "Konvertierungskonstruktor" << endl;
        myInt[0] = *( reinterpret_cast <char*> (&i)   );
        myInt[1] = *( reinterpret_cast <char*> (&i)+1 );
        myInt[2] = *( reinterpret_cast <char*> (&i)+2 );
        myInt[3] = *( reinterpret_cast <char*> (&i)+3 );
    }
};

// Konvertierungsoperator
MyInteger:: operator int()
{
     cout << "Konvertierungsoperator " << endl;
    return     *(reinterpret_cast <unsigned*> (myInt));
}

int main()
{
    // Konvertierungskonstruktor
    MyInteger my_int( 77777777 );
    cout << my_int << endl;

    // Standardkonstruktor
     MyInteger my_integer;

    // Konvertierungsoperator
      int i = my_integer;

    cout << i << endl;
    my_integer = my_int;

    cout << my_integer << endl;
    getchar ();
    return 0;
}

CStoll, letztendlich stoße ich aber trotzdem auf das Problem, dass ich nicht weiß, wie ich nun eine Datenstruktur sicher in eine Datei abspeichere. Soll ich mich dann immer auf diese Klasse beziehen, also z.B. in.read (my_integer, sizeof (my_integer)); schreiben, oder wie soll ich das lösen?

Edit, sorry muss mich berichtigen:

Wikipedia schrieb:

Plain Old Data Structures (PODS) are data structures [...]

Nach der Aussage müsste meine test-Struktur (eine Seite vorher) eh schon ein POD sein.

Du kannst deiner Klasse doch read/write-Funktionen (binär) bzw. operator<< >> (text) spendieren, so dass sie sich selbst vernünftig lesen und schreiben kann. Dann ist diese Herumcasterei unnötig. Konvertierungsoperatoren sollte man sowieso nur dann erzeugen wenn sie absolut nicht zu vermeiden sind.

Braunstein schrieb:

Du kannst deiner Klasse doch read/write-Funktionen (binär) bzw. operator<< >> (text) spendieren, so dass sie sich selbst vernünftig lesen und schreiben kann.

Casten werde ich so oder so müssen, wenn auch nur klassenintern. Anlass für diese ganze Problematik war ja das Dateihandling auf Zeichen/ASCII -ebene, weshalb ich den Code in meinem Programm auf Byteorientierung umschreiben musste/muss, weshalb relativ wenig Zeit bliebt, eine Klasse dafür zu implementieren. Aber es wäre natürlich eine bessere Lösung, wiegesagt, wenn mir jetzt noch jemand erklären könnte, wie das mit den read/write Methoden intern aussieht, dann ist mir sehr geholfen.

void MyInteger::write(ostream& out)
{
   out.write(reinterpret_cast<const char*>(myInt), sizeof(unsigned char));
   out.write(reinterpret_cast<const char*>(myInt+1), sizeof(unsigned char));
   out.write(reinterpret_cast<const char*>(myInt+2), sizeof(unsigned char));
   out.write(reinterpret_cast<const char*>(myInt+3), sizeof(unsigned char));
}

Also wenn ich anstatt std::string, char* nehme, wäre die Struktur also ein POD. Und das ist dann so okay, wenn ich nachfolgend mit der selben Methode ein und -aus lese?

Ja, dann wäre es ein POD - allerdings mußt du dich trotzdem selber darum kümmern, daß diese char-Zeiger auf intakte Daten verweisen - wenn du einfach die Adresse übernimmst, die beim letzten Programmlauf in die Datei geschrieben wurde, bekommst du nur Müll (und saubere char* Verarbeitung erfordert eigene Speicherverwaltung (Copy-Ctor/op=/Dtor) - damit bist du doch wieder bei einem Nicht-POD).

Aber es wäre natürlich eine bessere Lösung, wiegesagt, wenn mir jetzt noch jemand erklären könnte, wie das mit den read/write Methoden intern aussieht, dann ist mir sehr geholfen.

In deiner read/write kannst du natürlich die internen Daten binär speichern - wichtig ist nur, daß du alle relevanten Daten erwischst (bei Objekten variabler Größe gehören dazu auch die Größenangaben oder Endemarken), z.B.:

class test
{
  string data;
public:
  void writeto(ostream& out)
  {
    size_t sz = data.size()
    out.write((char*)&sz,sizeof(size_t));
    out.write(data.c_str(),sz);
  }
  void readfrom(istream& in)
  {
    size_t sz;
    in.read((char*)&sz,sizeof(size_t));
    data.resize(sz);
    in.read(&data[0],sz);
  }
};

write könnte so aussehen. [...]

Hehe danke, dann bestätigt das meine Frage von vorhin.

CStoll schrieb:

(bei Objekten variabler Größe gehören dazu auch die Größenangaben oder Endemarken) [...]

Geht klar, jetzt verstehe ich es Ich werde versuchen, es zu implementieren, und parallel zum Funktionstest meine Klasse hier zu posten, um eine Bestätigung dafür zu erhalten, ob es so stimmt. Vorläufig schonmal vielen Dank!