ich komme eigentlich aus der .NET Welt, bzw. C# Welt.

Jetzt frage ich mich, ob es in C++ ein äquivalentes Beispiel zu folgendem Beispiel gibt:

- Eine Basisklasse mit einer virtuellen Methode
- Eine Kindklasse A (erbt Basis), die die Methode mit [C#] override überschreibt
- Eine Kindklasse B (erbt Basis), die die Methode mit [C#] new überschreibt

Folgender Effekt:

Bei Variante A ist das Ergebnis, dass die Methode gänzlich überschrieben wird, auch wenn man die Basismethode durch einen Cast aufruft.
Bei Variante B ist nur eine neue Methode hinzugekommen, die die Basis Methode überdeckt. Ruft man die Basismethode durch einen Cast auf, so wird auch der Basiscode ausgeführt.

Wie sieht solch ein Besipiel in C++ aus?

Für Hilfe wäre ich sehr dankbar,
Norman-Timo

so ganz verstehe ich Deine Aussage jetzt nicht.

Also werde ich mal ein Beispielcode aus der C# Welt posten, vielleicht wird es dann klarer, was ich wissen will:

Die Basis:

public class Basis
    {
        // Konstruktor
        public Basis()
        { }

        // Methode zum Überladen
        public virtual string PolyMethod()
        {
            return "Hallo von der Basis!";
        }
    }

Variante A Klasse:

public class Kind_A : Basis
    {
        // Konstruktor
        public Kind_A()
        { }

        // Überladene Methode
        public override string PolyMethod()
        {
            return "Hallo von Kind_A!";
        }
    }

Variante B Klasse:

public class Kind_B : Basis
    {
        // Konstruktor
        public Kind_B()
        { }

        // Überladene Methode
        public new string PolyMethod()
        {
            return "Hallo von Kind_B!";
        }
    }

Wenn jetzt folgendes gemacht wird:

// lokale Variablen
Kind_A meinKindA = new Kind_A();
Kind_B meinKindB = new Kind_B();

// Variante A:
Console.WriteLine(
   meinKindA.PolyMethod()
   );
Console.WriteLine(
   ((Basis)meinKindA).PolyMethod()
   );

// Leerzeile
Console.Writeline();

// Variante B:
Console.WriteLine(
   meinKindB.PolyMethod()
   );
Console.WriteLine(
   ((Basis)meinKindB).PolyMethod()
   );

dann sieht man den Unterschied, denn als Ergebnis kommt folgendes zutage:

Hallo von Kind_A!
Hallo von Kind_A!

Hallo von Kind_B!
Hallo von der Basis!

Das würd ich gerne in C++ nachbauen, aber wie?

Gruß
Norman-Timo

vielen Dank für die doch überraschende aber klare Aussage.

Schade, ich habe gedacht, dass das zum OO gehört, und dass das auch in C++ so realisierbar ist. Aber dass das nicht geht habe ich verstanden.

Vielen Dank.

Gruß
Norman-Timo

da ich von der C# Welt komme, kenne ich dort zumindest das konkrete Beispiel die Methode ToString(), die JEDEM Objekt vererbt wird.

So ist das Problem, wenn ich diese Methode irgendwo fest überschreiben würde, dann wäre bei einem Cast auf ein hierarchisch höher liegenenden Typ die Eigenschaft verdreht, die die Methode eigentlich liefern sollte.

Also z.B. wenn ich bei einem UrUrUrVater die Methode aufrufe, könnte das eine andere Wirkung zeigen, wie wenn ich das von dem KindKindKind Objekt tun würde. Ein "Backcast" auf den UrUrUrVater sollte hier auch die ursprüngliche Methode liefern, weil sie z.B. in dessen Kontext sinnvoller ist.

Ich denke das ist schon recht "brauchbar", auch wenn bisher darauf verzichtet werden musste.

Nichtsdestotrotz, wenn ich mit einem Pfeil durch die Brust ins Auge schießen muss, nur um diesen Effekt in C++ zu erreichen, dann überlege ich mir lieber einen anderen Designansatz

Gruß
Norman-Timo

kann ich in C++ nicht immer auf eine Methode der Basisklasse zurückgreifen, in dem ich sie explizit aufrufe? Unter VS funktioniert es folgendermaßen:

Basisklasse:

class Basis
{
public:
	// Konstruktor
	Basis(void)
	{
	}

	// Methode zum Überladen
	virtual string PolyMethod(void)
	{
		return "Hallo von der Basis!";
	}
};

Abgeleitete Klasse:

class Kind_A :
	public Basis
{
public:
	// Konstruktor
	Kind_A(void)
	{
	}

	// Überladene Methode
	string PolyMethod(void)
	{
		return "Hallo von Kind_A!";
	}
};

Main:

int main(void)
{
	// lokale Variablen
	Kind_A meinKindA;

	// Ausgabe der redefinierten Methode
	cout << meinKindA.PolyMethod() << endl;

	// Ausgabe der Basismethode
	cout << meinKindA.Basis::PolyMethod() << endl;
	return 0;
}

erzeugt bei mir die Ausgabe:

Hallo von Kind_A!
Hallo von der Basis!

ja

Hm, soll das heißend, dass das standardkonform ist? Irgendwie bricht das mit dem Konzept von Vererbung finde ich... und kann ich das dann nur durch private/protected ableiten verhindern?

Jetzt lerne ich C++, Markt & Technik Verlag, 2000

da ich von der C# Welt komme, kenne ich dort zumindest das konkrete Beispiel die Methode ToString(), die JEDEM Objekt vererbt wird.

So ist das Problem, wenn ich diese Methode irgendwo fest überschreiben würde, dann wäre bei einem Cast auf ein hierarchisch höher liegenenden Typ die Eigenschaft verdreht, die die Methode eigentlich liefern sollte.

Also z.B. wenn ich bei einem UrUrUrVater die Methode aufrufe, könnte das eine andere Wirkung zeigen, wie wenn ich das von dem KindKindKind Objekt tun würde. Ein "Backcast" auf den UrUrUrVater sollte hier auch die ursprüngliche Methode liefern, weil sie z.B. in dessen Kontext sinnvoller ist.

Ich denke trotzdem, dass dies nicht sinnvoll ist, zumindest in C++ (für C# kann ich das nicht beurteilen). Denn durch einen Cast veränderst du das ursprünglich erstellte Objekt ja nicht. Du "interpretierst" es lediglich in einem engeren (Upcast) oder weiteren (Downcast) Kontext neu. Also wäre es auch unlogisch, wenn ein und dieselbe Funktion plötzlich was ganz anderes macht. Damit geht einfach ein Grundprinzip von OO verloren, indem du halt nicht mehr objektorientiert, sondern typorientiert denkst.

norman_timo schrieb:

Nichtsdestotrotz, wenn ich mit einem Pfeil durch die Brust ins Auge schießen muss, nur um diesen Effekt in C++ zu erreichen, dann überlege ich mir lieber einen anderen Designansatz

Ich wollte dir ja nur zeigen, dass es durchaus möglich ist. Empfehlen würde ich das aber nicht und ein anderer Designansatz ist auf jeden Fall der richtige Weg.

Knecht schrieb:

kann ich in C++ nicht immer auf eine Methode der Basisklasse zurückgreifen

Sofern public, ja. Damit brichst du aber im Beispiel das Open-Closed Prinzip, indem du Implementationsdetails freilegst, und ist daher nicht zu empfehlen.

Knecht schrieb:

kann ich in C++ nicht immer auf eine Methode der Basisklasse zurückgreifen

Sofern public, ja. Damit brichst du aber im Beispiel das Open-Closed Prinzip, indem du Implementationsdetails freilegst, und ist daher nicht zu empfehlen.

Klassen-Methoden sind doch in der Regel Öffentlich um dem Benutzer Zugriff auf private Element einer Klasse, in einem Vorgegebenen Rahmen zu ermöglichen. Eine Hirarchie/Vererbung kann ich aufbauen, wenn zwei Dinge verwand sind.

Z.B. ist ein Kreis eine sonderform der Ellipse. Ich kann also eine Kreis-Klasse von der Ellipsen-Klasse ableiten und die Methode zur Berechnung der Fläche der Ellipse (a*b*π) verbergen durch die Spezialisierung für den Kreis (r²*π) die angemessener und den meisten Menschen vertrauter ist. Deswegen ist es aber nicht prinzipiell "falsch" auf die Formel der Ellipsenfläche zurückzugreifen. Die liefert, vielleicht etwas umständlicher da nicht so spezialisiert, das richtige Ergebnis.

Deswegen hab ich aber doch noch keine Implementierungsdetails offengelegt, da ja beide Flächenberechnungs-Methoden "Zugriffs"-Methoden sind. Oder?!?

Danke für den Hinweis