Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
02.11.2006, 23:49 Uhr
~Gast
Gast

Hi.

Meine Frage ist eher theoretischer Natur und dreht sich darum, wieso der Polymorphismus mittels später Bindung realisiert ist?

Angenommen sei, es gibt eine Base-Class (Shape) und eine Sub-Class (Circle), wobei Circle die Methode Draw() von Shape überschreibt.

In jedem "Stück" Literatur über OOP (C++, Java, etc) heißt es:

"Eine Referenz eines bestimmten Typs / eine Funktion, die einen best. Typ erwartet kann NICHT wissen, ob es sich bei dem referenzierten Objekt um eben diesen bestimmten (erwarteten) Typ oder dessen "Unter-Typen" handelt!"

1)
Das ist schon das ganze Problem. Bis auf die verwirrende OO-Terminologie an sich müste man diese o.g. Zitate doch zunächst einmal richtigstellen, denn nicht eine Referenz oder eine Funktion kann "NICHT wissen .... ", sonder der Compiler!

2) Wieso aber soll der Compiler diese Informationen zur Compilier-Zeit nicht wissen? Schließlich stehen diese doch im Source-Code !
Jedesmal, wenn man ein Objekt an eine Referenz zuweist oder an eine Funktion übergibt, dann sieht doch der Compiler (anhand seiner Tabellen und anderen Verwaltungs-Infos etc) von welchem Typ dieses Objekt ist, unabhängig davon, wo diese Übergabe / Zuweisung im Code stattfindet.

Nun existiert in jeder der beiden Klassen-Definitionen die Methode Draw() und der Compiler hat die Infos, welche Methode zu welcher Klasse gehört, kennt noch die Typen der zu übergebenden Objekte und kennt zudem noch die Vererbungs-Beziehungen etc .....

=> also kann man doch erwarten, dass der er anhand dieser Typ-Infos die entsprechende Methode auch STATISCH zur Compile-Zeit dem jeweiligen Objekt zuweisen kann und folglich zur richtigen Methode verzweigt !?!?!?

=> Kann man es nicht so ausdrücken, dass die späte Bindung eine Alternative für die statische Realisierung des polymorphen Verhaltens ist und/oder die bevorzugte Realisierung !?

Bin für eine technische und detailreiche Erklärung dankbar ;-)

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
03.11.2006, 08:32 Uhr
ao

(Operator)

Nur so hingekritzelt, ich hoffe, es stimmt halbwegs:

C++:

#include <list>
class Shape
{
public:
    virtual void Draw () = 0; // Platzhalter für die Malfunktion
};

class Circle : public Shape
{
    virtual void Draw ();    // Kreis malen
};

class Rectangle : public Shape
{
    virtual void Draw ();    // Rechteck malen
};

int main (void)
{
    // Figuren definieren und in einer Liste speichern
    std::list<Shape *> shapes;
    shapes.push_back (new Circle (1, 2, 3));
    shapes.push_back (new Rectangle (1, 2, 3, 4));

    // anderer Code

    // Jetzt alles malen
    for (std::list<Shape*>::iterator shape = shapes.begin ();
         shape != std::list<Shape*>::end ();
         shape++)
    {
        shape->Draw ();
    }

    return 0;
}

Die Liste shapes enthält die Figuren über Basisklassenzeiger, d.h. für den Compiler ist keine Information sichtbar, um welche konkrete Figur es sich handelt. Dass die ein paar Zeilen weiter oben definiert wurden, zählt nicht; das könnte auch an ganz anderer Stelle passiert sein. Die Schleife, die alles malt, könnte eine eigene Funktion sein, die nur eine list<Shape*> hereingereicht bekommt ohne zu wissen, wie die Figuren erzeugt wurden.

Späte Bindung heißt: Erst zur Laufzeit steht fest, was das genau für ein Ding ist, das da über seinen Basisklassenzeiger gemalt werden soll.

Jetzt klarer?

ao

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
03.11.2006, 14:49 Uhr
~Gast
Gast

Jau. Am Beispiel mit der Liste wird alles klar !
Danke

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: