Objekte in Datei schreiben und lesen!

OK jetzt weiss ich warum immer nur 1 Name in der Datei steht, weil sie immer wieder neu angelegt wird, denn die Methode wird ja auch mehrmals angelegt. Definier ich dieses:
std::ofstream out("datei.txt");

außerhalb der Methode schreibt er komischerweise gar nichts mehr in die Datei. Komisch...!

virtuell Realisticer

Nabend,

sorry, king, darauf musste ich noch hinweisen :), kannst dich ja bald mal revanchieren

Warum musst du immer so unverschaemt sein?

@vr: Was du sagst ist mir bekannt, eogentlich wollte ich nur wissen was das "HALT" sollte? Ich _habe_ doch die tollen Ströme benutuzt, auch wenn ich << und >> nicht überladen habe.

Ups, sry. Da hab ich dich glaube ich falsch verstanden :). So ein 'halt'
rutscht mir manchmal auch raus, das ist mit Sicherheit nicht persoenlich
gemeint gewesen. Er wollte lediglich darauf hinweisen, dass man hier
prima den Op << und >> auf otzes Art und Weise (jaja ich meine das so :D)
ueberladen kann.

Zum Thema Listen. Eine einfach verkettete Liste implementiert man i.d.R so:

class Person{
private:
    string name;
    Person *next;
public:
    Person() 
        : next(0) //0 makiert das ende
    {}
    //ich versteh nicht ganz, warum hier Person**? 
    //void setDaten(Person **liste_pointer);
    //so ganz spontan haette ich das so gemacht:
    void setDaten(const Person& p);
    void getDaten();

    friend std::ostream &operator<<(std::ostream &out,Person const &p) {
    out << p.name << '\n';
    return out;
  }
    friend std::istream &operator>>(std::istream &in,Person &p) {
    std::getline(in,p.name);
    return in;
  }
};

void Person::setDaten(const Person& p){
    Person* tmp = this; //this ist kopf der liste
    Person* newPerson = new Person;

        //daten kopieren
        newPerson->name = p.name;

        //an das ende der liste laufen
        while(tmp)
            tmp = tmp->next;

        //wir sind am ende angelangt, newPerson ist das neue
        //letzte element
        tmp = newPerson;
        tmp->next = 0; //damit o. schleife auch funktioniert
}

//die funktionalitaet sollte jetzt klar sein
void Person::getDaten(){
    Person* tmp = this;
        while(tmp) {
            cout<<name<<endl;
            tmp = tmp-> next;
        }
}

Hoffe ich hab jetzt keinen Fehler gemacht und dir ist das Prinzip klar geworden.

mfg
v R

Wie rufe ich diese Liste denn in MAIN auf und wo gebe ich den Namen ein ?
Das Speichern/Lesen ist ja noch nicht integriert, mal abgesehen von den Funktionen. Hast du da noch ne Idee ?

ness

Hä? Sicher das amn so eine Liste implementiert? Also vom Prinzip her schon, aber ich kann ja nicht mal nen name speichern? Oder bin ich blöd?
@Annika:
Speichern ist von einzelnen Personen ist implementiert, und das ist nur ein Bsp. Wenn du sowas benutzen willst, kannste std::list benutzen. Wenn dus selber implementieren willst (zu übungszwecken) musst du das natürlich noch erweitern.
Mir sagt übrigens die ganze Listenklasse nicht zu und mindestens einen Destruktor würde ich noch vorschlagen!

virtuell Realisticer

ness schrieb:

Hä? Sicher das amn so eine Liste implementiert? Also vom Prinzip her schon, aber ich kann ja nicht mal nen name speichern? Oder bin ich blöd?

Ups, hab en Fehler drin. Bei setDaten tmp = next setzen. Und ja, en DTor sollte
noch rein, um die Liste wieder zu loeschen.

Bei mir wird die Liste ordnungsgemaess angelegt.

[edit]
Die Schleife in setData muss noch raus
[/edit]

mfg
v R

ness

Und wie soll man den namen von ner Person ändern? Ein Iterator wäre nicht schlecht, und rein oop-technisch würde ich aus Person nen struct machen und ein template einfach_verkettete_liste einführen...

@virtuell Realisticer

Kannst du bitte nochmal schreiben wie die MAIN Funktion von Deinem geposteten Code aussieht ?

Vielen Dank.

rüdiger

otze schrieb:

[...]

richtig wärs wohl so:
template<class charT,class traits>
friend std::basic_ostream<charT,traits> &operator<<(std::basic_ostream<charT,traits> &out,Personen const &p)
sorry, king, darauf musste ich noch hinweisen :), kannst dich ja bald mal revanchieren

ja, natürlich! Wie konnte ich nur!

virtuell Realisticer

ness schrieb:

Und wie soll man den namen von ner Person ändern? Ein Iterator wäre nicht schlecht, und rein oop-technisch würde ich aus Person nen struct machen und ein template einfach_verkettete_liste einführen...

Naja, i.d.R. aendert sich der Name einer Person nicht im laufe seines Lebens. Ein
Iterator koennte man in der Tat noch machen. Und ob du ein struct oder ein class
nimmst, ist "oop-technisch" egal. Bis auf die Standardsichtbarkeit verhalten sich
beide Konstrukte gleich. Der Einfachheit halber wuerde ich persoenlich ein
std::list fuer sowas nehmen, aber wenn es nur zur Uebung ist.

@virtuell Realisticer

Kannst du bitte nochmal schreiben wie die MAIN Funktion von Deinem geposteten Code aussieht ?

Vielen Dank.

Du solltest etwas mehr eigeninitiative zeigen. Auf die main-Funktion sollte
man jetzt sehr leicht kommen. Sie koennte z. B. so aussehen:

int main() {
    Person person;
    Person tmp;
    char end;

        while(end != 'n') {
            cout<<"Personenname: ";
            cin >> tmp;
            person.setDaten(tmp);
            cout<<"Noch mehr Personen? ";
            cin >> end;
        }

    return 0;
}

[edit]
Hmmm...offentsichtlich bin ich zu bloed geworden, um eine Liste zu
implementieren :(. Die Liste funktioniert nicht so, wie sie soll, aber ich
kann mich im Moment nicht darum kuemmern, muss ja auch was arbeiten ;).

Heut Abend, wenn ich die Zeit bekomme, werde ich mir das nochmal anschauen.
Soll trotzdem niemanden daran hindern, hier was zu posten.
[/edit]

mfg
v R

virtuell Realisticer

Morgen,

also ich konnte das nicht so auf mir sitzen lassen. Hier der Code, der bei mir
funktioniert (MinGW Developer Studio mit gcc):

class Person{
private:
    string name;
    Person *next;
public:
    Person(const std::string& n)
        : name(n), next(0) //0 makiert das ende
    {}
	Person()
		: name(""), next(0)
	{}
	~Person();
    //ich versteh nicht ganz, warum hier Person**?
    //void setDaten(Person **liste_pointer);
    //so ganz spontan haette ich das so gemacht:
    void setDaten(const Person& p);
    void getDaten();

    friend std::ostream &operator<<(std::ostream &out,Person const &p) {
    out << p.name << '\n';
    return out;
  }
    friend std::istream &operator>>(std::istream &in,Person &p) {
    std::getline(in,p.name);
    return in;
  }
};

Person::~Person() {
    delete next;
}

void Person::setDaten(const Person& p){
    Person* tmp = this; //this ist kopf der liste
    Person* newPerson = new Person(p.name);

	while(tmp->next)
	    tmp = tmp->next;

        //wir sind am ende angelangt, newPerson ist das neue
        //letzte element
        tmp->next = newPerson;
        tmp->next->next = 0; //damit o. schleife auch funktioniert
}

//die funktionalitaet sollte jetzt klar sein
void Person::getDaten(){
    Person* tmp = next;
        while(tmp) {
            cout<<tmp->name<<endl;
            tmp = tmp->next;
        }
}

int main() {
   Person person;
   Person tmp;
   char   End = 'j';

	while(End != 'n') {
	    cout<<"Namen eingeben: ";
	    cin >> tmp;
	    person.setDaten(tmp);
	    cout<<"Noch eine Person anlegen? ";
	    cin >> End;
	}

    person.getDaten();

    return 0;
}

mfg
v R