c++.de :: CASTS: dynamic_cast und static_cast ???

Unregistrierter

Ich was das das "CASTEN" auf deutscht besetzen heisst und, dass man es für Klassenhierarchien. Was genau jedoch bringt mir das nun wenn ich einen UpCast oder DownCast oder CrossCast mache ??? Für was ist das genau ?? Was ist die Verwendung dafür ?? Wie sieht das in einem konkreten Beispiel aus ???

THANX

------------------
°°°Simon says°°°
Nimm RAT von allen,
aber spar dein URTEIL.
~~~~~~~~~~~~~~
FOR more www.klapaucius.20m.com
Moderator@pub44.ezboard.com/bsecurityprojektz
Member of Swisshackinggroup.de

Stefan Dreckmann Mitglied 22:23:00 17.01.2001 Titel:

Casten ist die explizite Typumwandlung eines Ausdrucks. Du sagst dem Compiler, daß er einen bestimmten Ausdruck (z.B. eine Variable) verwenden soll, als hätte dieser den angegebenen Typ.

In C-Programmen hat man das relativ häufig benötigt, während es in C++-Programmen meistens ein Zeichen schlechten Designs ist und so gut es geht vermieden werden sollte, z.B. durch Einsatz von Vererbung und virtuellen Methoden.

Casten wird im Prinzip nötig, wenn Du an einer Stelle mehr weißt, als der Compiler (oder zumindest mehr zu wissen glaubst ;-)). Durch den Cast zwingst Du ihn, die Sache genauso zu sehen, wie Du. Etwa:

C++:
void f(void arg) { // Ich WEISS, daß arg ein Pointer auf MyClass ist: MyClass cls = static_cast<MyClass *>(arg); }

Die Cast-Arten, die Du nennst, beziehen sich tatsächlich auf Klassen (geht natürlich nur mit Pointern oder Referenzen):

Ein UpCast ist ein Cast die Klassenhierarchie hinauf, also von einer Unterklasse auf eine Oberklasse.

Ein DownCast ist ein Cast in die andere Richtung, also von einer Oberklasse auf eine Unterklasse.

Ein CrossCast ist ein Cast von einer Geschwisterklasse auf eine andere.

Beispiele:

C++:
1 2 3 4 5 6 7 8 9 10 11	class A { // ... }; class B: public A { // ... }; class C: public A { // ... };

UpCast: Ich brauche nicht explizit zu casten, das kann der Compiler selbst:

C++:
void f(B* pb) { A *pa = pb; }

DownCast: Falls pa nicht _wirklich_ ein B* ist, wird pb nach der Zuweisung 0 sein.

C++:
void f(A pa) { B pb = dynamic_cast<B *>(pa); }

CrossCast: Auch hier ist das Ergebnis des Casts 0, falls pb nicht wirklich vom Typ C* ist.

C++:
void f(B pb) { C pc = dynamic_cast<C *>(pb); }

UpCasts sind gang und gäbe. Das sieht man schon daran, daß es der Compiler auch ohne Deine Hilfe kann. Ein Pointer oder eine Referenz auf eine Unterklasse kann immer auch wie ein Verweis auf die Oberklasse verwendet werden. Er "bedeutet" ja weniger als der Verweis auf die Unterklasse.

Die beiden anderen Cast-Arten sind schon bedenklicher. Insbesondere der CrossCast ist in meinen Augen ein Signal dafür, daß an dem Design des Programms wirklich etwas nicht stimmt!

Stefan

[ 05.10.2001: Beitrag editiert von: HumeSikkins ]