Pointer auf unbekannten Typen.

C++ Forumbot

Dieser Thread wurde von Moderator/in Jochen Kalmbach aus dem Forum C++/CLI mit .NET in das Forum C++ verschoben.

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

Dieses Posting wurde automatisch erzeugt.

CStoll

Templates werden bereits zur Compilezeit instanziiert - auf deutsch: die Parameter durch einen vorgegebenen Typ ersetzt. Da kannst du nicht zur Laufzeit den Typ ändern, auf den der Zeiger verweist.
(überhaupt ist es nur eingeschränkt möglich, den Typ einer Variable zur Laufzeit zu unterscheiden)

Also: Was genau hast du eigentlich vor?

Tobias W

Du könntest das ganze als void Pointer durchreichen, und wenn du an den Verarbeitungspunkt kommst, per RTTI & dynamic_cast den Typ zuweisen. Mit RTTI meine ich jetzt die Nutzung vom Operator typeid().

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.

Simon2

Moritz06 schrieb:

...
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.

Moritz06

Danke für die Antworten,
der void* pointer konnte mein Problem lösen.
Trivial eigentlich, hätte ich wirklich mal drauf kommen können.
Danke für eure Hilfe und das Beispiel und sorry, dass ich wohl im falschen Forum gepostet habe.

Moritz

ein void pointer lässt sich glaube nicht mehr anstandslos kompillieren, warum noimmst du keine new template<class T> wenn du was zur laufzeit erzeugen willst....

CStoll

dgrat schrieb:

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

hustbaer

Tobias W schrieb:

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).

Tobias W

Stimmt, der Code würde so nicht klappen. Aber ist auf jeden Fall ein Hinweis wie man an die Sache rangehen könnte.

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.

C-Chris

Was bringt den ein Zeiger auf einen unbekannten Typen?! Irgendeinen Nutzen? Der Code wird dadurch doch nur unübersichtlich.