Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
14.12.2006, 10:42 Uhr
Soto

Hallo allerseits,

nehmen wir mal an, es gibt drei Klassen A, B und C.
A ist abstrakt, B erbt von A und C erbt wiederum von B.

Nun sollen Objekte der Klassen B und C verwaltet werden.
Dazu wird ein Zeiger auf Objekte von A verwendet.

C++:

A* R;

Von diesen Objekten soll nun eine Methode do_something() aufgerufen werden, die in B,
aber nicht in A steht.

Daher wird der Zeiger auf (B*) gecastet.

C++:

(*(B*)R).do_something()

Also soweit sollte es gehen.

Nun meine Frage:
Angenommen, diese Methode do_something() ist in der Klasse C überschrieben worden und greift auf Elemente zu, die nur in C stehen.
Funktioniert es dann, diese Methode über einen Zeiger auf B-Objekte aufzurufen? Das sollte problemlos gehen, oder? Oder muss ich noch extra für C-Objekte den Zeiger nach C* casten?

Ich kann gerne noch ein Beispielprogramm posten, falls noch nicht klar ist, was ich meine.
--
ich versuche zu helfen, sorry wenn ich nen scheiß rede ^^

Profil || Private Message || Suche

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

001
14.12.2006, 11:02 Uhr
Th

Diese C-Casts sind sehr unschön in C++ Programmen. Benutzte lieber die zugehörigen C++ Casts, d.h. static_cast, dynamic_cast bzw. reinterpret_cast.

Wenn do_something als virtuell (virtual) deklariert ist, dann ist das kein Problem, sondern sogar extra so gedacht, daß man über einen Basiszeiger (ohne cast) auf die Methode zugreifen kann.
Wenn du aber nur Basiszeiger (A*) verwendest, dann solltest du evtl. die Methode do_something() schon hierdrin als virtuell bzw pure virtuell ( = 0 ) deklarieren. Dann benötigst du keine Casts mehr, sondern kannst über den Basiszeiger auf beliebige abgeleitete Klassen-Objekte zugreifen.
z.B.

C++:

class A
{
public:
     virtual void do_something() = 0;
};

class B : public A
{
public:
     virtual void do_something()
     {
          cout << "Ich bin B!" << endl;
     }
};

class C : public B
{
public:
     virtual void do_something()
     {
          cout << "Ich bin C!" << endl;
     }
};

std::vector<A*> vA;

vA.push_back(new B());
vA.push_back(new C());

for(size_t n = 0; n < vA.size(); n++)
    vA[n]->do_something();

Dieser Post wurde am 14.12.2006 um 11:04 Uhr von Th editiert.

Profil || Private Message || Suche

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

002
14.12.2006, 11:05 Uhr
Soto

Du meinst, die Casts sind unschön, weil nicht überprüft wird ob richtig gecastet wird?
--
ich versuche zu helfen, sorry wenn ich nen scheiß rede ^^

Profil || Private Message || Suche

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

003
14.12.2006, 11:11 Uhr
Th

Exakt, denn wenn es noch eine andere Klasse gibt, die von A ableitet, dann knallt der Aufruf von do_something (undefiniertes Verhalten).
Mittels "dynamic_cast<B*>(pA)" kannst du überprüfen, ob pA ein B (oder davon abgeleitete Klasse ist). Wenn nicht kriegst du einen Null-Zeiger geliefert, also erst casten und anschließend bei nicht null die Methode aufrufen.

Aber besser ist eigentlich der Ansatz mit virtuellen Methoden, dann benötigst du (fast) gar keine Casts mehr.

Profil || Private Message || Suche

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

004
14.12.2006, 11:14 Uhr
Soto

Besten Dank, damit sind meine Fragen glaub ich beantwortet.
--
ich versuche zu helfen, sorry wenn ich nen scheiß rede ^^

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: