Bsp:

class Base
{
  Base() { var = 0; }
  int var;
};

class Derived : public Base
{
  Derived() {}
};

int main()
{
  Base b;
  Derived *pD;
  pD = &b;                     //dies gibt einen Fehler und soll nur grob verdeutlichen, was ich meine
  pD->var = 5;                 //nun soll der Member var von b 5 sein
}

Ich halte es für eher unwahrscheinlich, dass es eine Möglichkeit gibt, Zeile 16 durch etwas synonymes zu ersetzen, aber vielleicht gibt es eine andere Möglichkeit, um dies zu erreichen. Ich brauche dies, da ich einen vector mit verschiedenen Typen gefüllt habe (bisher mit zweien), die allerdings voneinander abgeleitet sind (ich habe dies über unions erreicht). Wenn ich nun in einer Funktion nur einen Zeiger der abgeleiteten Klasse erstelle, weil ich nunmal auf deren Eigenschaften zurgeifen möchte und weise diesem Zeiger ein Element des vectors zu, in dem die Basisklasse gespeichert ist, so möchte ich, dass der Zeiger ganz normal auf die Member der Basisklasse zugreifen kann (die neuen Member der abgeleiteten Klasse hätten dann automatisch einen Standardwert, der im Konstruktor festgelegt wird). Ich könnte natürlich auch noch einen Zeiger der Basisklasse erstellen, dies würde aber umständlicher sein und außerdem verbraucht es mehr Speicher.
Hat vielleicht jemand eine Idee, das umzusetzen?

Packe beide Klassen in eine Union und lass den Zeiger auf diese union zeigen.

Wenn du in einem Vektor Objekte von mehreren verschiedenen Klassen speichern möchtest, die alle eine gemeinsame Basisklasse haben, dann solltest du einen std::vector<Base *> verwenden, und die Objekte selbst mit new allokieren.

Außerdem wirfst du in deinem Text ein bißchen Objekte und Zeiger durcheinander. Ein Objekt hat immer nur einen Typ, entweder Base oder Derived, egal welche Sorte von Zeiger du gerade auf das Objekt hältst. Wenn du wirklich von Base* nach Derived* casten mußt, dann wäre dynamic_cast das Stichwort. Aber auch da gilt wieder, daß das bei einem sauberen Design in den wenigsten Fällen nötig sein sollte.

Viele Grüße,
Michael

Wenn ich einen Vektor std::vector<Base *> erstelle und dort dann per Polymorphie verschiedene abgeleitete Objekte "reinstecke", dann kann ich mit dynamic_cast nur das abgeleitete Objekt bekommen, wenn es auch wirklich auf diese abgeleitete Klasse zeigt. Es wäre sehr bequem, wenn ich die Objekte in dem Vektor beliebig in andere Typen konvertieren könnte, allerdings so, dass ich trotzdem auf den gleichen Ort zeige und direkt darauf zugreifen kann. Ich halte es inzwischen allerdings unwahrscheinlich, dass das möglich ist.
Ich werde es also so machen, wie ihr vorgeschlagen habt. Das ist natürlich ein wenig umständlicher.

Decimad schrieb:

Dieser Cast wird erst während der Laufzeit durchgeführt und ist natürlich ziemlich aufwendig, weil dafür für alle Objekte zur Laufzeit deren Typinformation benötigt wird und verglichen werden muss.

Ich kenne den dynamic_cast erst seit kurzer Zeit und ich wollte mal fragen, ob es sich nun lohnt, ihn zu benutzen, da er ja anscheinend etwas Zeit verbraucht. Mit unionen, so würde ich vermuten, geht es schneller. Man muss dabei natürlich aufpassen, welche Variable man nun benutzt

Base b;
  Derived *pD;
  pD = &b;                     //dies gibt einen Fehler und soll nur grob verdeutlichen, was ich meine

Polymorphie hat den Sinn, einen Zeiger oder eine Referenz auf eine Basisklasse zu haben, der/die generische Funktionalität besitzt. Das heisst, hinter dem Zeiger/der Referenz muss sich nicht umbedingt tatsächlich eine Basisklasse befinden; eine abgeleitete ist auch möglich. Was du versuchst, ist jedoch das Umgekehrte.

King_Luc schrieb:

Es wäre sehr bequem, wenn ich die Objekte in dem Vektor beliebig in andere Typen konvertieren könnte, allerdings so, dass ich trotzdem auf den gleichen Ort zeige und direkt darauf zugreifen kann. Ich halte es inzwischen allerdings unwahrscheinlich, dass das möglich ist.

Du kannst die Zeiger schon so hinbiegen, dass sie auf irgendein Objekt zeigen. Nur führt das weder zu definiertem Verhalten noch hat es sonst einen Sinn.

King_Luc schrieb:

Ich kenne den dynamic_cast erst seit kurzer Zeit und ich wollte mal fragen, ob es sich nun lohnt, ihn zu benutzen, da er ja anscheinend etwas Zeit verbraucht. Mit unionen, so würde ich vermuten, geht es schneller. Man muss dabei natürlich aufpassen, welche Variable man nun benutzt

Du solltest erst auf Performance achten, wenn du wirklich merkst, dass es nötig ist. Wie gesagt, benutze keine Unions in C++. Für Non-PODs geht das sowieso nicht, und selbst für PODs wirst du sie kaum brauchen.

Unabhängig davon ist auch dynamic_cast nicht eine sehr schöne Lösung. Das meiste kann man mit virtuellen Funktionen erreichen.

Es wäre sehr bequem, wenn ich die Objekte in dem Vektor beliebig in andere Typen konvertieren könnte, allerdings so, dass ich trotzdem auf den gleichen Ort zeige und direkt darauf zugreifen kann.

Da stellt sich doch erstmal die Frage, warum die Objekte dann überhaupt von verschiedenen Klassen sind. Wenn die Objekte einander so ähnlich sind, daß sie beliebig hin- und herkonvertiert werden können, warum gehören sie dann nicht auch alle zu ein und derselben Klasse?

Ich habe eine Klasse von einer anderen abgeleitet und nun von der abgeleiteten Klasse einen Zeiger erstellt. Diesen möchte ich nun auf ein Objekt der Basisklasse zeigen lassen, wobei ich auch nur die Eigenschaften der Basisklasse benutzen möchte. Der Zeiger soll vollen Zugriff auf die Funktionen und Variablen des Objekts der Basisklasse besitzen.

Dies geht grundsätzlich nicht, und macht auch keinen Sinn. Das hat alleine schon mit dem Speicherlayout zu tun. Wenn du ein Objekt der Basisklasse auf einen Zeiger auf eine davon Abgeleitete Klasse umbiegst (C-Cast und reinterpret_cast sollten das an sich ermöglichen), so ist ein Zugriff auf diesen Zeiger schlicht und ergreifend kritisch zu nennen.

Was soll bitteschön passieren, wenn du auf eine Methode/Member zugreift die nicht zu der Basisklasse gehört? Das Verhalten ist undefiniert. Es könnte deine Festplatte formatieren, einfach nur einen dahinterliegenden Speicherbereich als Wert interpretieren...

Basisklassen dienen nicht dazu auf untergeordnete Klassen zu verweisen, sondern um als gemeinsame Schnittstelle von davon abgeleiteten zu dienen.

Davon abgesehen noch ein paar andere Punkte:
a) Zugriffsmodifikatoren hast du wohl in der Eile vergessen (public:...)
b) Ich würde Membervariablen möglichst nicht öffentlich deklarieren, selbst Setter/Getter die nichts anderes als den Zugriff weiterleiten haben einen Vorteil: Du kannst später noch einen Zugriffsschutz oder Bereichsüberprüfungen ohne große Codeänderung einfügen.
c) Basisklassen sollten im Regelfall immer über einen virtuellen Destruktor verfügen.

cu André

c) Basisklassen sollten im Regelfall immer über einen virtuellen Destruktor verfügen.

... wenn sie in polymorphen Kontexten benötigt werden.

asc schrieb:

c) Basisklassen sollten im Regelfall immer über einen virtuellen Destruktor verfügen.

... wenn sie in polymorphen Kontexten benötigt werden.

Was zumindestens bei mir der Regelfall ist (und ansonsten sollte man wenigstens die Regel mit dem private-Konstruktor einhalten, den unbedachtes "Vergessen" ist nicht unüblich...).

Wenns unbedingt sein muss, machste halt ein Cast..

http://www.c-plusplus.net/forum/viewtopic-var-t-is-229749.html

Inzwischen ist mir aufgefallen, dass es nicht viel aufwendiger ist, und dass es wirklich keinen Sinn hat, teilweise auf Eigenschaften eines Objekts zugreifen zu wollen, die dieses eigentlich nicht besitzt.

Danke für die vielen und hilfreichen Antworten!