Eigene Klassenstruktur mit Stream-Operator?

Angenommen ich habe Klasse A, Klasse B erbt von A.

Für Die Basisklasse A habe ich folgendes definiert:

friend std::ostream& operator <<(std::ostream &os, const A &msg);

Jetzt gebe ich alle Attribute von A formatiert aus. Klasse B soll das gleiche tun, allerdings zusätzlich die Attribute von Klasse A ausgeben.

Ich habe das jetzt so gelöst, in dem ich in der Header/CPP-Datei von Klasse B erneut den <<-Operator überlade:

std::ostream& operator <<(std::ostream &os,const B &msg) {
	std::cout<<(A)msg<<std::endl;
	std::cout<<"Hier Attribute von B ausgeben"<<std::endl;
	return os;
}

Frage: Macht man das so?. Problem ist, ich muss mehrmals den friend deklarieren, das finde ich blöde. Genau wie den Cast

Bin nicht ganz sicher was du meinst. Dieser überladene Operator ist ja im Prinzip auch nur eine Methode.

Ich habe dich jetzt so verstanden, das der Stream Operator in beiden Klassen überladen wird. Das diese Methode aber etwas anderes tut. Also praktisch eine andere Implementierung hat. Da wäre jetzt das Stichwort Polymorphismus was für dich (wenn du es so gemeint hast. Schau mal nach Polymorphismus und Schlüsselwort virtual im Netz.

RHBaum

Macht man das so?. Problem ist, ich muss mehrmals den friend deklarieren, das finde ich blöde. Genau wie den Cast

Schlecht ^^
Nicht virtuelle Funktionen (ein operator ist eine nichtvirtuelle funktion) sollt man in abgeleiteten klassen nicht ueberschreiben .. das macht alles konfus ^^

Besser:
- Den operator nur fuer die Basisklasse definieren
- im Operator eine virtuelle funktion nutzen
- in der abgeleiteten Klasse die virtuelle funktion so ueberschreiben, das das rauskommt was sehen willst

Ciao ...

Jockelx

Halo,

du kannst in den Streamoperatoren auch einfach eine virtual-public-stream-Funktion aufrufen.
Die abgeleiteten Funktionen rufen die Basis-Funktion auf.
cast und friend fallen so weg.

KN4CK3R

du kannst auch noch eine vererbare Funktion PrintToStream o.ä. machen

std::ostream& operator <<(std::ostream &os,const A &msg)
{
    return msg.PrintToStream(os);
}

std::ostream& A::PrintToStream(std::ostream &os)
{
    os << ...A...;
    return os;
}

std::ostream& B::PrintToStream(std::ostream &os)
{
    auto os2 = A::PrintToStream(os);
    os2 << ...B...;
    return os2;
}

Dass du im Operator dann statt os cout benutzt, ist auch nicht Sinn der Sache

greetz KN4CK3R

krümelkacker

Sollen die B-Attribute auch ausgegeben werden, wenn du nur eine Referenz auf den A-Teil hast? Falls ja, schreit das gerade zu nach Polymorphie. Das könnte man so machen:

class A
{
public:
  virtual void tostream(ostream& out) const;
:::
};

inline ostream& operator<<(ostream& out, A const& obj)
{ obj.tostream(out); return out; }

void A::tostream(ostream& out) const
{
  out << "[Ich bin ein A]";
}

class B : public A
{
public:
  void tostream(ostream& out) const override;
:::
};

void B::tostream(ostream& out) const
{
  A::tostream(out);
  out << "[Ich bin auch ein B]";
}

int main()
{
  B obj;
  A const& aref = obj;
  cout << aref << endl;
}

Ok ok ich muss eure Antworten lesen, aber ich denke ich hab's jetzt schon verstanden (polymorphe Klasse durch virtuelle Ausgabemethode)

Ok, bleibt eine Frage

krümelkacker schrieb:

class A
{
public:
  virtual void tostream(ostream& out) const;
:::
};

class B : public A
{
public:
  void tostream(ostream& out) const override;
:::
};

Ist override lediglich eine Hilfe für den Programmierer und kennzeichnet ab C++11x überschriebene virtuelle Funktionen?
Gibt es eigentlich ein gutes Buch, wo all diese kleinen Dinge vom neuen Standard kurz erläutert werden?

krümelkacker

Windows7 schrieb:

Ist override lediglich eine Hilfe für den Programmierer und kennzeichnet ab C++11x überschriebene virtuelle Funktionen?

Es ist ein C++11 Feature und ist dazu da, dass du als Programmierer deine Intention bzgl Überschreiben deutlich machen kannst. Es führt allerdings auch dazu, dass der Compiler dies überprüft und ggf eine Fehlermeldung ausspuckt, falls die Signatur gar nicht auf eine in einer Basisklasse deklarierten virtuellen Funktion passt. In dem Fall würdest du nämlich einfach eine neue Funktion definieren und keine alte überschreiben. Aber das passt ja dann nicht mit deiner Intention zusammen und kann deswegen als Fehler erkannt werden.

Windows7 schrieb:

Gibt es eigentlich ein gutes Buch, wo all diese kleinen Dinge vom neuen Standard kurz erläutert werden?

Siehe http://www.stroustrup.com/C++11FAQ.html