Struktur mit überladenen <<Operator speichern?

[_freeze_]

Hey @all,

ich habe das normale überladen der operatoren hoffentlich verstanden, :p
jedoch stehe ich vor dem nächsten Problem.:( Und zwar würde ich gerne eine
Struktur speichern.

Also habe ich mir soetwas gedacht:

#include <iostream>
#include <fstream>
#include <ostream>
#include <string>
#include <vector>

using namespace std;

class test {
  private:
    struct person {
      char name[50];
      char vname[30];
      char telefon[20];
    };
    vector<person> vp;

  public:
    test() {
    }
    ~test() {
    }
    void add(std::string name, std::string vname, std::string telefon) {
      person p;
      strncpy(p.name, name.c_str(), sizeof(p.name));
      strncpy(p.vname, vname.c_str(), sizeof(p.vname));
      strncpy(p.telefon, telefon.c_str(), sizeof(p.telefon));
      vp.push_back(p);
    }
    void write(std::string filename) {
      fstream file(filename.c_str(), ios::out | ios::app | ios::binary);
      if(file) {
        for(unsigned int i=0; i<vp.size(); i++)
          file << vp[i];
      }
    }
    friend ostream& operator<<(ostream &f, const person &p) {
      return f.write(reinterpret_cast<const char*>(&p), sizeof(&p));
    }
};

int main(int argc, char* argv[]) {
  test* te = new test();
  string n, vn, t;
  cout << "Name: ";
  getline(cin, n);
  cout << "Vorname: ";
  getline(cin, vn);
  cout << "Strasse: ";
  getline(cin, t);
  te->add(n, vn, t);
  te->write("test.dat");
  getline(cin, t);
  return 0;
}

Jedoch irgendwie habe ich doch etwas mißverstanden bei den
Operator-Überladungen

Könnte mir da jemand helfen?
Denn normalerweiße geht ja das auch:

fileOut.write(reinterpret_cast<const char*>(&p), sizeof(&p));

Vielen Dank im Voraus
Lg _freeze_

[volkard]

fileOut.write(reinterpret_cast<const char*>(&p), sizeof(p));

[_freeze_]

volkard schrieb:

fileOut.write(reinterpret_cast<const char*>(&p), sizeof(p));

Ja, also irgendwie kenn ich mich nicht aus, denn so wie Du es geschrieben hast, hatte ich es versucht, jedoch hat es nicht funktioniert. Wie Du ja selbst in meinem Beispiel gesehen hast.

Das was Du als Lösung vorgeschlagen hast, funktioniert normal mit Strukturen, jedoch nicht im Überladenen Operator.

Lg _freeze_

[davie]

volkard schrieb:

sizeof(p)