ich habe ein Programm was eine Varialbe unbekannten Typs übergeben bekommen soll. Diese soll dann in einem Klassentemplate weiterverarbeitet werden.

Wie kann ich das realisieren?

Im Grunde müsste ich sowas wie:

template <typename T>
const T* pointer;

...

template <class T>
class ClassTemp{
public: do(<T> Zeiger);

...

ClassTemp<pointer->gettype()> Instanz;
Instzanz.do(&pointer)

Ist es überhaupt möglich einen Zeiger auf einen unbekannten Typ zu erstellen?

Viele Danke für alle Antworten,

Moritz

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Also: Was genau hast du eigentlich vor?

Kleines Beispiel:

#include <typeinfo>

class A
{
  // bla
};

class B
{
  // blub
};

void irgendein_verarbeitungspunkt(void* a_param)
{
  if(typeid(a_param) == typeid(A))
  {
    A* l_classA = dynamic_cast<A*>(a_param);
    if(l_classA != NULL)
    {
      // do something
    }
  } else if(typeid(a_param) == typeid(B))
  {
    B* l_classB = dynamic_cast<B*>(a_param);
    if(l_classB != NULL)
    {
      // do something else
    }
  } else
  {
    // Fehlerbehandlung
  }
}

Aber Vorsicht, ich hab das nicht ausprobiert. Sollte aber klappen. Bitte verbessert mich falls nicht.

Die schönste Methode ist das allerdings nicht. Wäre besser das zu verhindern...

Edit:
Wenn ich jetzt so CStolls Beitrag lesen, glaub ich hab Moritz06 missverstanden.

...
Ist es überhaupt möglich einen Zeiger auf einen unbekannten Typ zu erstellen?
...

Klar !
Aber die Frage ist: Was willst Du damit machen ?
und damit die Frage: Ab wann (und wodurch) soll aus dem "unbekannten" ein "bekannter" Typ werden ? (denn nur mit denen würde ich arbeiten)

Gruß,

Simon2.

Moritz

ein void pointer lässt sich glaube nicht mehr anstandslos kompillieren,

Warum nicht - du mußt ihn nur vor Verwendung in etwas sinnvolles umcasten.

warum noimmst du keine new template<class T> wenn du was zur laufzeit erzeugen willst....

Templates werden bereits zur Compilezeit instanziiert - etwas zu früh für diese Zwecke

Bitte verbessert mich falls nicht.

Nö, kann nicht klappen, da weder typeid noch dynamic_cast mit void* funktionieren. Für beide brauchst du als Ausgangspunkt einen Zeiger auf eine "polymorphe" Klasse, also eine mit mindestens einer virtuellen Funktion.
Wenn man allerdings irgendwie anders wissen kann was der Typ des Objektes ist funktioniert es mit typeid sehrwohl.

Noch ein Fehler in deinem Code: Angenommen a_param ist ein Zeiger aauf T, dann ist typeid(a_param) gleich typeid(T*) und nicht typeid(T) bzw. typeid(derived_from_T). Um auf typeid(derived_from_T) zu kommen müsstest du typeid(*a_param) schreiben.

Und natürlich ... wenn du schon einen T* hast und weisst dass er in wirklichkeit auf ein A zeigt, dann kannst du einfach einen static_cast nehmen - dynamic_cast ist da nicht notwändig (Ausnahme: virtuelle Vererbung ist im Spiel).

Aber wie ich ja auch schon gesagt habe, sollte man das casten von void Pointern doch vermeiden. Es gibt meistens die Möglichkeit das zu verhindern.