Zugriffsverletzung beim dynamic_cast

kartoffelsack

Ich bekomm irgendwie schwer nachvollziebar Zugriffsverletzungen beim dynamic_cast. Bein CBuilder wirft dann ne EAccessviolion.

Jetzt frag ich mich, ob es standardmäßig überhaupt möglich ist, dass beim dynamic_cast Exception geworfen wird???

Könnte es sein, dass der Zeiger, den ich caste schon garnicht ok ist und es dann irgendwie hakt, weils ja dann keinen virtual table gibt?

RTTI aktiviert?

davie

standardmäßig wird von dynamic_cast höchstens bad_cast geworfen.
allerdings gibt es viele dinge, die undefiniertes verhalten hervorrufen.
Zeig etwas Code.
Das was sein könnte, kann tatsächlich sein. dynamic_cast braucht (meistens) einen vtable.

rüdiger

bei der Verwendung von Pointern sollte dynamic_cast eigentlich nichts schmeißen.

weils ja dann keinen virtual table gibt?

das versteh ich nicht. Klassen ohne vtable kannst du nicht casten.

naja, versuch mal nen minimales Code Beispiel zu erzeugen, was das Problem verdeutlicht

davie

also, hab schnell folgendes zusammengetragen:

#include <iostream>
#include <cassert>
#include <typeinfo>
using namespace std;

class A {
public:
	void f () { cout << "A::f\n"; }
};

class B : public A {
public:
	void f () { cout << "B::f\n"; }
};

class X {
public:
	void f () { cout << "X::f\n"; }
	virtual ~X () {} //wenn du keine funktionen virtuell machen willst, aber RTTI verwendest
};

class Y : public X {
public:
	void f () { cout << "Y::f\n"; }
};

int main () {
	A a; B b;

	A *pa = &b; //geht
	pa = dynamic_cast<A*>(&b); //geht auch (ein bisschen zuviel des guten)
	A &ra = b; //geht
	A &ra2 = dynamic_cast<A&>(b); //geht auch

	//B *b = dynamic_cast<B*>(&a); //geht nicht => kein vtable

	X x; Y y;

	X *px = &y;
	Y *py = dynamic_cast<Y*>(&x); //geht (gcc gibt warnung), aber:
	assert (py == 0); 
	py = dynamic_cast<Y*>(px); //geht

	try {
		Y &ry = dynamic_cast<Y&>(x); //geht, aber
	} catch (std::bad_cast&) {
		cout << "Wowie\n";
	}
	Y &ry = dynamic_cast<Y&>(*px); //geht
	ry.f();
}

mit void geht überhaupt nix

kartoffelsack

RTTI etc ist alles aktiv, Vererbungshierarchie is ok.

Naja Codebeispiel kann ich nicht so wirklich geben.

Aber in meinem Proggie fliegt (aber nicht immer und nur nach Lust und Laune des Rechners) in ner Zeile wie

A* pa(dynamic_cast<A*>(pB));

ne EAccessviolation. Und das kann ja wohl irgendwie nicht sein. Meine einzige Vermutung wäre, dass pB schon irgendwohin ins Nirvana zeigt und es deswegen dazu kommen könnte (pB ist aber nach meinen Untersuchungen vollkommen ok).

HumeSikkins

standardmäßig wird von dynamic_cast höchstens bad_cast geworfen.

Bei der Anwendung auf eine ungültige Referenz.

bei der Verwendung von Pointern sollte dynamic_cast eigentlich nichts schmeißen.

Richtig. Da liefert dynamic_cast im Fehlerfall einen entsprechenden Nullpointer.

Down- oder Crosscasts können mit dem dynamic_cast nur durchgeführt werden, wenn es sich bei den beteiligten Typen um polymorphe Typen handelt (ein Typ mit mindestens einer virtuellen Funktion).

Zu dem eigentlichen Problem kann ich aber leider nichts sagen

Mr. N

Und was is mit:

class A { // ... bla ...
};
class B { // .... bla ...
};
// ...
dynamic_cast<A*>((B*)0x785677);

oder so?

Hintergedanke: Er überprüft zwar vielleicht, ob p!=0, aber ansonsten dereferenziert er. Und wenn das bei nem zB deleteten Pointer geschieht => BUMMS (besser gesagt UB, aber ...)!