final overrider

TS++

Hallo zusammen!

Es geht mal wieder um Mehrfachvererbung!

Angenommen ich hätte folgende Klassenhierarchie:

+---------------------+
                       |         base        |
                       +---------------------+
                       +---------------------+
                       |+abstract func():void|
                       +---------------------+
                                  ^
                                  |
             +-----------------virtual----------------+
             |                                        |
   +--------------------+                   +--------------------+
   |       ClassA       |                   |       ClassB       |
   +--------------------+                   +--------------------+
   +--------------------+                   +--------------------+
   |+virtual func():void|                   |+virtual func():void|
   +--------------------+                   +--------------------+
             ^                                         ^
             |                                         |
             +---------------------+-------------------+
                                   |
                        +--------------------+
                        |      ClassAB       |
                        +--------------------+
                        +--------------------+
                        +--------------------+

Ich hätte auf anHeap eigentlich angenommen, dass in Abhängigkeit von der Ableitungsreihenfolge die abstrakte Routine func aus base zunächst mit func() aus ClassA und dann mit func aus ClassB überschrieben wird.
Ein Aufruf folgender Art dürfte dann eigentlich keine Schwierigkeiten bereiten:

ClassAB obj;
obj.func();

Nur mein Compiler (IDE=DevC++) ist damit nicht ganz einverstanden!
Meldung: ClasAB.h : void ClassA::func() needs a final overrider

Klar, ich könnte jetzt natürlich hergehen, und func in ClassAB nochmal überschreiben:

virtual void func()
{
   ClassB::func();
}

Dann hätte ich ja genau was ich will!
Meine Frage ist jetzt nur: liege ich mit meiner Vorstellung vom Überschreiben der func-Routine jetzt völlig daneben, oder ist diese Implementierung vom Compiler abhängig?

Danke!

Grüße,
TS++

[ Dieser Beitrag wurde am 12.05.2003 um 11:55 Uhr von TS++ editiert. ]

kartoffelsack

Du liegst völlig daneben

Die Reihenfolge spielt keine Rolle. Der Compiler findet zwei funcs und weiß nicht, welche er nehmen soll. Welches benutzt werden soll( A::func, B::func, alles beide oder was ganz anderes) kann nur AB wissen und muss demzufolge dort festgelegt werden

Helium

Jup und ein using kann da sehr hilfreich sein. Und virtuelle Vererbung natürlich auch.

[ Dieser Beitrag wurde am 12.05.2003 um 10:41 Uhr von Helium editiert. ]

Walli

Original erstellt von kartoffelsack:
Du liegst völlig daneben

Also ich nehme in solchen Fällen immer einen speziellen Random-Compile-Mode . Dann entscheidet der Compiler wie er was kompiliert. *nichternstnehmen*

[ Dieser Beitrag wurde am 12.05.2003 um 12:00 Uhr von MaSTaH editiert. ]

TS++

Der ist wahrscheinlich bei vielen Compilern als DefaultMode angegeben!

MaSTaH: Du nervst.

@<Rogero>
Er hilft aber wenigstens anderen weiter. Ich fands by the way lustig

volkard

Ich muß dich erstmal wegen deines Beispiels anpflaumen: So Buchstaben A un B sind zu unkonkret, daß man dran was kapieren könnte. Ich habs mal geändert.

+---------------------+
                       |         Boot        |
                       +---------------------+
                       +---------------------+
                       |+virtual double getMaxSpeed() const
                       +---------------------+
                                  ^
                                  |
             +-----------------virtual----------------+
             |                                        |
   +--------------------+                   +--------------------+
   |       Motorboot    |                   |       Segelboot    |
   +--------------------+                   +--------------------+
   +--------------------+                   +--------------------+
   |+double getMaxSpeed() const             |double getMaxSpeed() const
   +--------------------+                   +--------------------+
             ^                                         ^
             |                                         |
             +---------------------+-------------------+
                                   |
                        +--------------------+
                        |      Motorsegler   |
                        +--------------------+
                        +--------------------+
                        +--------------------+

So, und hier wolltest Du wisen, warum der COmpiler dir nicht verraten will, wie schnell dein Motoesegler ist. Also cout<<ms.getMaxSpeed()<<endl; geht nicht. Da hat er recht. Willste wissen, wie schnell der Motorsegler segeln kann, oder willste wissen, woe schnell er mit dem Motor ist?
Kannst in der main den Motorsegler auch jederzeit für den Funktionsaufruf mal in ein Motorboot oder Segelboot casten. Mußt nicht in Motorsegler ne Funktion getMaxSpeed anbieten, wenn sie inhaltlich nicht ok ist. Dann laß sie weg und dann kannste halt nicht einfach so auf nem Motorsegler getMaxSpeed aufrufen.

1ntrud0r

ich meinte auch das er da was mit dem oop nicht ganz so richtig verstanden hat

TS++

@1ntrud0r: niemals voreilig urteilen!

Das die Logik hinter dem Bootbeispiel die Frage bedeutungslos erscheinen lässt, ist mir schon bewusst. Gerade aus diesem Grund habe ich ja auch neutrale Klassenbezeichnungen gewählt!
Mir ging es mehr um die prinzipielle Frage, ob bei einem Aufeinandertreffen mehrerer virtueller Methoden mit gleicher Struktur und gleicher Bezeichnung ein automatisches Überschreiben in konkreter Reihenfolge stattfindet.
(wäre ja durchaus möglich, dass in Abhängigkeit von der Ableitungsreihenfolge doppelte Routinen automaisch überschrieben werden und nur noch eine einzige Implementierung übrigbleibt -> die Anwendung wäre trotz mehrfach vererbter Routinen lauffähig (ob die Routine auch wirklich das enthält, was man will, das ist wieder eine andere Frage => müsste dann über die Ableitungsreihenfolge festgelegt werden!))

==> dem ist offensichtlich nicht so und das weiss ich jetzt!
(mich hat im Übrigen auch nur der Ablauf während der Übersetzung interessiert!)

Trotz einiger unhöflicher Untertöne, Danke!
(damit richte ich mich an alle Quereinsteiger, die ausser dummen Sprüchen
nichts zu bieten haben)

Volkard, Danke!
Von dir kriegt man wenigstens noch halbwegs vernünftige Beiträge zu lesen!

Grüße,
TS++

[ Dieser Beitrag wurde am 12.05.2003 um 15:23 Uhr von TS++ editiert. ]

[ Dieser Beitrag wurde am 12.05.2003 um 15:33 Uhr von TS++ editiert. ]