C++ Unterschiedliche Objekttypen in eine Variable speichern

[olli45 (Gast)]

Hallo,

ich habe ein Objekt, welches eine Variable enthält in der 
unterschiedliche Objekte (bzw. Pointer auf diese) gespeichert werden 
müssen (immer nur ein Objekt aber es gibt mehrere mögliche Typen)
Geht so etwas denn?

[Manfred K. (mkch)]

Hallo,
ich habe mal in einem Forum ein Beispiel mit einer "Union" gesehen. 
Damit kann man verschiedene Datentypen quasi übereinander legen. 
Vielleicht hilft das ja ihr Problem zu lösen.
Gefundenes Beispiel siehe Attachment. Im Beispiel wird die "Union" 
genutzt, um auf einzelne Bytes von verschiedensten Mehrbyte-Variablen 
zuzugreifen. Das Gleiche müsste eigentlich mit unterschiedlichen 
Zeigervariablen auch funktionieren.
Viele Grüße Manfred

[Rufus Τ. F. (rufus)]

olli45 schrieb:
> Geht so etwas denn?

Sofern die unterschiedlichen Objekte eine gemeinsame Basisklasse haben: 
Ja. Der Pointer ist dann einfach ein Pointer vom Typ der Basisklasse.

Allerdings musst Du Dir dann auch was einfallen lassen, was Du mit den 
Objekten dann machen willst, d.h. wie Du sie aus der Variablen (dem 
Pointer) wieder 'rausbekommst, um mit ihnen etwas anzufangen.

[Bernd K. (prof7bit)]

olli45 schrieb:
> immer nur ein Objekt aber es gibt mehrere mögliche Typen

Wenn alle Objekte von der selben Basisklasse erben wäre das gängige 
Praxis in den meisten objektorientierten Sprachen, bzw eigentlich eine 
der Hauptmotivationen wozu Vererbungspolymorhismus überhaupt erfunden 
wurde.

[Rolf M. (rmagnus)]

Suchst du std::variant (falls das dein Compiler schon hat)?
http://en.cppreference.com/w/cpp/utility/variant

Alternativ boost::variant
http://www.boost.org/doc/libs/1_61_0/doc/html/boost/variant.html

Eine gemeinsame Basisklasse wäre aber ein besserer Ansatz, falls das in 
deinem Fall möglich ist.

[Dennis H. (c-logic)]

Polymorphie ist der Ansatz.

Man bestimmt durch die Basisklasse eine Sammlung von standardisierten 
Funktionen über welche jedes Objekt ansprechbar sein soll als virtuell.
In der Abgeleiteten Klasse definierte man diese und kann durch casten 
auf die Basisklasse die abgeleitete Klasse mit diesen Funktionen 
ansprechen.
Abstrakte/Virtuelle Funktionen oder gar Basisklassen sind da das Mittel 
zu Wahl.

[Tom (Gast)]

Wenn (Zeiger auf) verschiedene Arten von Objekten in einer Variablen 
gespeichert werden sollen, ist es sehr wahrscheinlich, dass sie eine 
Gemeinsamkeit (aus Sicht des Objekts, das dann auf die verschiedenen 
Objekte zuzugreift) haben. Genau diese Gemeinsamkeit steckt man in eine 
Basisklasse und erbt von dieser.

[Wilhelm M. (wimalopaan)]

Wie wäre es mit einem Klassen-Template?
Die Vorgehensweise hängt von den Anforderungen ab. Sollen die 
(Hüll)-Objekte als Instanzen in einem Container gespeichert werden, dann 
scheidet diese Lösung allerdings aus (da unterschiedliche 
Parametrierungen zu unterschiedlichen konkreten Typen führen).

[Oliver S. (oliverso)]

olli45 schrieb:
> ich habe ein Objekt, welches eine Variable enthält in der
> unterschiedliche Objekte (bzw. Pointer auf diese) gespeichert werden
> müssen

Ums mal zusammenzufassen:

WARUM?

Beschreib doch mal etwas ausführlicher das Problem (und weniger die 
angedachte Lösung).

Oliver

[Milhouse van Hauten (Gast)]

>>immer nur ein Objekt aber es gibt mehrere mögliche Typen

Verschiedene Typen kannst du nicht in einer gemeinsamen Variable 
speichern.
Wahrscheinlich schwebt dir vor, dass die Objekte um die es geht 
"sinngemäß" das gleiche tun, dieses aber jeweils auf eine andere Art?

Das ist die Spielwiese für Interfaces.
Die Variable, welche die Referenz hält, ist dann vom Typ des Interfaces.
Wenn jede Klasse, welche das Interface implementiert für jede Methode 
eine andere Implementierung hat, brauchst du keine Basisklasse.
Gibt es aber im Interface einen Pool an Methoden, die in jeder späteren 
Instanz gleich ist, dann macht eine Basisklasse Sinn. Die währe dann 
nicht instanziierbar, weil sie nicht ALLE Methoden des Interfaces 
implementiert.
Diese werden dann in den letztendlichen Klassen implementiert.

>Interface_ABC definiert Methode A ; B und C

>BaseClass_AB ergbt von Interface "ABC" und implementiert nur Methode A und B

>Variant_1_Class_C erbt von BaseClass_AB und implementiert Methode C
>Variant_2_Class_C erbt von BaseClass_AB und implementiert Methode C

>Beide Variant Klassen kannst du jetzt in einem Zeiger vom Typ Interface_ABC 
>referenzieren.