ich bekomme einen Zeiger auf einen Typen übergeben, von dem mehrere andere Typen abgeleitet werden. Jetzt möchte ich überprüfen, ob dieser Zeiger auf einen bestimmten abgeleiteten Typ und ihn dann Casten. Ungefähr so:

try {
  MyPointer = dynamic_cast<TMyPointer*>(MyPara);
} catch (...) {
  throw "Wrong type";
}

Jetzt kann MyPointer aber von irgendeinem der abgeleiteten Typen sein, sodass ich den Cast-Typ ermitten muss. Im Prinzip so:

try {
  MyPointer = dynamic_cast<typeof(MyPointer)>(MyPara);
} catch (...) {
  throw "Wrong type";
}

Geht das und wenn ja, wie?

template< typename To, typename From >
void inplace_dynamic_cast( To*& to, From* from )
{
    to = dynamic_cast< To* >( from );
}

inplace_dynamic_cast( MyPointer, MyPara );

BTW: Wenn Du beim Cast eine Exception fangen möchtest, musst Du Referenzen statt Pointer casten.

Erstmal: Ein fehlgeschlagener dynamic_cast auf einen Pointer wirft keine Exception sondern gibt 0 zurück. Du musst also darauf testen.
typeof gibt es im aktuell gültigen Standard nicht. Was willst du damit eigentlich erreichen?
Evtl. gibt es einen anderen Weg.

class foo
{
public:
   virtual void func() { cout << "foo" << endl; }
};

class bar : public foo
{
public:
   virtual void func() { cout << "bar" << endl; }
};

// ...
foo *ptr = new bar;
ptr->func(); // Ausgabe: bar

Sonst ergibt das nämlich nicht viel Sinn. Was hast du davon, wenn du den Pointer in einen Typen umwandeln kannst, den du gar nicht kennst? Entweder du willst auf Member zugreifen, die im Basisklaseninterface definiert sind (-> virtuelle Funktionen) oder auf typspezifische Member, die du aber gar nicht kennen kannst.

Erstmal: Ein fehlgeschlagener dynamic_cast auf einen Pointer wirft keine Exception sondern gibt 0 zurück.

Zitat aus "C++ Primer":

(...), when a cast fails, it throws a std::bad_cast exception.

Hört sich für mich schon so an...

Der Hintergrund ist: Ich habe ein Frame, dessen Konstruktor einen Owner (TComponent) übergeben bekommt. Diesen Owner speichere ich entsprechend gecastet in einer privaten Eigenschaft, da ich bestimmte Komponenten von ihm verwende (und bei ihm voraussetze). Wird das Formular jetzt woanders verwendet, möchte ich nur die Definition der privaten Eigenschaft ändern, sonst nix. In dem Konstruktor möchte ich also den Owner-Parameter auf den Typ von PrivateOwner casten um ihn dann in selbigen zu speichern.

Du könntest nach allen möglichen abgeleiteten Klassen Probe-casten und das nehmen das keinen Nullpointer zurückgibt...

The value of a failed cast to pointer type is the null pointer value of the required result type. A failed cast to
reference type throws bad_cast (18.5.2).

Ich würde dir vorschlagen aus deinem Frame eine Template Klasse zu machen wenn es denn wirklich nötig ist den genauen Typ zu können.
Ich frage mich allerdings warum das nötig ist. Wenn du den genauen Typ des Owners wisse willst, dann willst du vielleicht auf Membervaraiblen oder -funktionen zugreifen die nur da existieren.
Dann hättest du aber auch unterschiedlichen Code je nach Owner-Typ. Das sieht mir dann eher weider danach aus einfach speziell dafür angepasste Frames zu nehmen.

#include <typeinfo>
#include <iostream>
#include <string>

class X
{
public:
	virtual std::string GetType()
	{
		return typeid(*this).name();
	}
};

class A : public X
{
};

class B : public X
{
};

int main()
{
	X *a = new A;

	std::cout << a->GetType() << std::endl; // vom Typ "class A"

	delete a;

	a = new B;

	std::cout << a->GetType() << std::endl; // vom Typ "class B"

	delete a;
}

Ist das hier wirklich der Fall?
Keine dieser Klassen hat irgendwelche Membervariablen.

Aus dem C++-Standard:

5.3.4/3 schrieb:

In the first alternative (delete object), if the static type of the operand is different from its dynamic type, the static type shall be a base class of the operand’s dynamic type and the static type shall have a virtual destructor or the behavior is undefined. In the second alternative (delete array) if the dynamic type of the object to be deleted differs from its static type, the behavior is undefined.73)

In der Praxis wird es vielleicht wegen der fehlenden Member funktionieren, aber es besteht keine Garantie. Ausserdem ist es sehr schlechter Stil, polymorph genutze Klassen ohne virtuellen Destruktor auszustatten. Nicht zuletzt habe ich das angemerkt, weil ich kürzlich einige Stunden wegen genau diesem idiotischen Fehler debuggt habe.

Ich habe sowas auch noch nie gemacht. Es gibt aber bei uns Kollegen die meinen das sei kein Problem. Deswegen die Frage.