Überschreibe beim Laden wohlmöglich den Stack. Nur wo?

Und wie mache ich das mit dem Überladen der Streams?! Habt ihr vielleicht einen Link wo das erklärt ist? Ich versteh nicht wie man >> oder << überladen kann?! Und vorallem wie man das dann anwendet. Und das mit den stingstreams geht wie ich es mache auch nicht. wenn ich direkt von dem string in die Float bzw Int schreiben will, meckert der Compiler ;_(

Videonauth

Von String in einen Integer bzw Float kannst du mit atoi(string/char array) für Integer und atof(string/char array) lösen.

http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/
http://www.cplusplus.com/reference/clibrary/cstdlib/atof/

und hier noch ne kleine URL zu Operatoren

http://www.gia.rwth-aachen.de/Lehre/Cpp/script/online/node141.html

Travor

Wenn du eine schnelle Hilfe brauchst, dann:
http://www.parashift.com/c++-faq-lite/input-output.html#faq-15.8

SeppJ

EiGelbb schrieb:

Und wie mache ich das mit dem Überladen der Streams?! Habt ihr vielleicht einen Link wo das erklärt ist? Ich versteh nicht wie man >> oder << überladen kann?! Und vorallem wie man das dann anwendet.

http://www.c-plusplus.net/forum/232010

Und das mit den stingstreams geht wie ich es mache auch nicht. wenn ich direkt von dem string in die Float bzw Int schreiben will, meckert der Compiler ;_(

Was willst du auch mit dem String? Schreib doch einfach in den Stream, ganz ohne Zwischenschritte! Und lesen genau umgekehrt!

Videonauth schrieb:

Von String in einen Integer bzw Float kannst du mit atoi(string/char array) für Integer und atof(string/char array) lösen.

http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/
http://www.cplusplus.com/reference/clibrary/cstdlib/atof/

Das halte ich für einen ganz schlechten Ratschlag. Zum einen braucht er hier gar nichts umzuwandeln. Zum anderen, falls er es doch mal brauchen sollte, ist die Methode die er jetzt hat schon ganz ok. Vielleicht mal als Funktion, anstatt 30x den gleichen Code wiederholen. Und als Template.

Das mit dem Überladen des << versteh ich zum Teufel komm raus nicht...
Was soll mir das bringen, wenn ich da &ostream operator<<(ostream &xy, yx); hab?
Wofür brauche ich da den Rückgabewert, was bewirkt dieses Überladen nun und wie schreibe ich dann?
Ich krieg gleich ein Herzkasper, da ich nirgendwo im Internet was finde, womit ich es finde. Immer steht nur: Überlade einfach und dann einfach ausgeben.

Hilfee! Ich versteh das hinten und vorne nicht. :_(

SeppJ

EiGelbbb schrieb:

Das mit dem Überladen des << versteh ich zum Teufel komm raus nicht...
Was soll mir das bringen, wenn ich da &ostream operator<<(ostream &xy, yx); hab?
Wofür brauche ich da den Rückgabewert, was bewirkt dieses Überladen nun und wie schreibe ich dann?

#include <iostream>
#include <string>

using namespace std;

class Datum
{
  int tag, monat, jahr;
  friend istream& operator>>(istream &in, Datum &datum)
  {
    char point;
    return in >> datum.tag >> point >> datum.monat >> point >> datum.jahr;
  }
};

class Stueck_Obst
{
  string sorte;
  Datum ablaufdatum;
  friend istream& operator>>(istream &in, Stueck_Obst &obst)
  {
    return in >> obst.sorte >> obst.ablaufdatum;
  }
};

int main()
{
  Stueck_Obst foo;

  // Datensätze von der Form
  // Orange 12.34.4567
  // Banane 76.43.2135
  // usw.

  // *****************************************
  // Wie du einen Datensatz einlesen würdest:

  // Nein. Das kann ich einfach nicht vormachen. Versuchs mal selber.
  // *****************************************

  // *****************************************
  // Wie man viel einfacher einen Datensatz einlesen würde:
  cin >> foo;
  // *****************************************
}

Außerdem nochmal eine frühere Antwort:

SeppJ schrieb:

Siehe meine Signatur. Du brauchst aber kein weiterführendes Buch, dir fehlen sämtliche wichtigen Grundlagen.

Dein früheres Buch war wohl nicht so gut. Der Title kommt mir auch schon verdächtig vor.

Ich glaub, ich bin einfach zu dumm um C++ zu lernen... Seit zwei Stunden verusche ich das Überladen zu verstehen, und ihr seit so nett und versucht mir zu helfen, aber bei mir steht da oben immer noch dick 'Bahnhof'.

Frage 1: was bewirkt das

char point

da? Und wo ist das definiert? Wie weiß der Compiler jetzt, dass er bei cin >> keine tastatureingabe erwarten soll sondern aus einer Datei lesen soll? Das soll er da doch oder? Ich sehe nicht, so cin gesagt wird, dass er überladen handeln soll. Und wie das mit Outpur geht weiß ich auch immer noch nicht...

Wenn ich jetzt eine Klasse Player habe:

ostream& operator<<(std::ostream& os, const player xy) 
 { 
     os << xy.getAiFood(); 
     return os; 
 }

Das würde doch jetzt bewirken, dass ich in den ersten Paramter des Operators, also in ein ostream-Objekt den Wert von xy.getAiFood() schreiben würde. Doch wie rufe ich diese Funktion auf? Irgendwo muss ich doch die Paramter übergeben? Also

ostream abc("filename.dat");
<<(abc,xy);

oder wie? Das sieht mehr sehr falsch aus.
Logischer würde mir

ostream abc("filename.dat");
abc << xy;

erscheinen. Doch: Wo wird da dem << gesagt, dass er überladen ist?!
Und wie lade ich das jetzt wieder? Ich schreibe ja nicht nur einen sondern gleich mehrere in eine Datei. getline kann ich ja nicht sagen. Wer weiß, ob dass Alles in einer Zeile steht.

Also, meine konkreten Fragen:

-Woher weiß cin >>, welchen ostream ich meine?! Da steht ja nichts von einem ostream, sondern nur, dass ein Objekt eingelesen werden soll.
-Wie funktioniert das speichern und lesen mehrerer Elemente.
-Was bewirkt das char point in deinem Beispiel?
-WIE FUNKTIONIERT DAS?!

Mein Problem ist wohl, dass alle Bücher bisher immer nur die Oberflächen erklärt haben.

"Mit cin >> gibst du Daten ein"... Doch was der Operator >> nun wirklich könnte, was cin eigentlich bedeutet, etc wird nirgends erklärt

Oder vielleicht bin ich wirklich nur zu dumm um das Alles zu verstehen

SeppJ

EiGelbbb schrieb:

Mein Problem ist wohl, dass alle Bücher bisher immer nur die Oberflächen erklärt haben.

"Mit cin >> gibst du Daten ein"... Doch was der Operator >> nun wirklich könnte, was cin eigentlich bedeutet, etc wird nirgends erklärt

Oder vielleicht bin ich wirklich nur zu dumm um das Alles zu verstehen

Deine Bücher machen das vielleicht so. Die Erklärung die du hier als Beispiel gibst ist auch schlecht bis falsch. Du hast auch tatsächlich überhaupt nicht verstanden, was cin bedeutet. Aber das sind viel zu viele, viel zu lange Fragen und die werden auch noch Folgefragen nach sich ziehen. Das kann ich nicht alles beantworten. Daher: Lies ein gutes Grundlagenbuch! Nichts für Spieleprogrammierer, für Dummies, von A bis Z oder in 21 Tagen, sondern ein gutes Buch!

314159265358979

cin ist selbst ein Streamobjekt des Typs std::ostream.

TyRoXx

314159265358979 schrieb:

cin ist selbst ein Streamobjekt des Typs std::ostream.

ne, istream

Hm, ok... Habe jetzt mal etwas rumprobiert.

Müsste es dann so aussehen?

ostream& operator<<(ostream &Stream, player& B)
{
Stream << B.getAiGold() 
<< B.getAiFood() 
<< B.getAiIron() 
<< B.getAiStone()
<< B.getAiWood() 
<< B.getDevelopment()
<< B.getForceStrength() 
<< B.getHumor() 
<< B.getInhabitants() 
<< B.getProsperty() 
<< B.getTimesPlayerRejectedOffer() 
<< B.getTimesTradedWithPlayer();
	return Stream;
}

istream& operator>>(istream &Stream, player& B)
{
	Stream >> B.aiGold 
>> B.aiFood 
>> B.aiIron 
>> B.aiStone 
>> B.aiWood 
>> B.development 
>> B.forceStrength 
>> B.aiHumor 
>> B.aiInhabitants 
>> B.prosperty 
>> B.timesPlayerRejectedOffer 
>> B.timesTradedWithPlayer;

return Stream;
}

?

314159265358979

TyRoXx schrieb:

314159265358979 schrieb:

cin ist selbst ein Streamobjekt des Typs std::ostream.

ne, istream

Ahjo, genau.

SeppJ

EiGelbb schrieb:

Hm, ok... Habe jetzt mal etwas rumprobiert.

Müsste es dann so aussehen?

Das sieht nicht verkehrt aus. Ob's natürlich richtig ist, dafür müsste ich deine Klassen genau kennen (aber das wäre mir wahrscheinlich auch zu viel Arbeit, wenn deine Klassen so aussehen, wie ich befürchte). Funktioniert es denn?

Wie du an deinem Code hoffentlich merkst, musst du an sehr viele verschiedene Sachen denken und wehe, du vergisst einen der Werte. Das liegt da dran, dass deine Klassen viel zu viele verschiedene Attribute haben. Die Namen deuten darauf hin, dass die eigentlich zu verschiedenen Untergruppen (z.B. ai) gehören, die du aber nicht konsequent ausmodelliert hast.

Ja, soweit schon. Nur habe ich Testweise alle Klassenvariabeln auf Public: gestellt. Muss ich wirklich immer temporäre ints etc anlegen und darüber dann set-Funktionen aufrufen?
Oder kann mein Stream auch gleich die Werte einer Funktion übergeben? Also,

Stream >> B.setAiWood(?????)

Doch was wäre dann der Funktionsparameter, der den Wert übermitteln sollte?!

Vielen Dank außerdem für eine andauernde und kompetente Hilfe!

SeppJ

Mach die Funktion doch einen friend, so wie ich das im Beispiel gemacht habe, wenn dich das stört. Ansonsten ist die Benutzung von public-Funktionen für diese Anwendung nicht unüblich.

Wo ist denn eigentlich noch der Unterschied zu einem public-Member, wenn bei dir alles einen eigenen Getter und Setter hat? Wieder schlechtes Klassendesign. Machen deine Objekte überhaupt etwas oder sind das nur Datensammlungen?

Naja, der Spieler interagiert halt mit sehr viel mit den Objekten. Friend Deklaration hatte eben noch Fehler hervorgerufen, aber ich probiere es morgen noch mal. Hatte heute Abend nicht mehr die Muse, den Fehler zu suchen.

Du meinst also, die get/ set Funktionen gegen Friend-Deklaration austauschen?

SeppJ

EiGelbbb schrieb:

Du meinst also, die get/ set Funktionen gegen Friend-Deklaration austauschen?

Absolute Aussagen sind ausnahmslos immer schlecht.

Das kann man nicht so pauschal sagen. Beschäftige dich mal etwas mehr mit den Grundlagen des objektorientierten Designs, dann verstehst du, worauf ich hinaus möchte und kannst dann selber passende Entscheidungen treffen. Ist nicht schwer. Bloß fehlt dir das nötige Wissen. Daher nochmals der Hinweis auf Lehrbücher. Oder für dieses Thema sollte dir auch das Internet schon gut helfen können. Punkt ist eben, dass sowohl exzessives friend als auch exzessive getter und setter die Kapselung aufweichen, die man eigentlich erreichen möchte (aber in vielen schlechten Büchern wird das falsch vorgemacht, da die Autoren es selber nicht besser wissen), wodurch man sich die Mühe auch gleich hätte sparen können. Aber sie machen das jeweils beide ein bisschen anders und die Konsequenzen sind daher auch andere.