dynamic_cast works only on polymorphic types, i.e. classes containing virtual functions. In gcc you can dynamic_cast to void* but not from: struct S { virtual ~S() {} }; int main() { S* p = new S(); void* v = dynamic_cast<void*>(p); S* p1 = dynamic_cast<S*>(v); // gives an error }
Firstly, you need to measure the performance over a lot more than just a few iterations, as your results will be dominated by the resolution of the timer. Try e.g. 1 million+, in order to build up a representative picture. Also, this result is meaningless unless you compare it against something, i.e. doing the equivalent … Read more
Yes, this is correct behaviour. The reason is that you can have a null pointer, but not a null reference – any reference has to be bound to an object. So when dynamic_cast for a pointer type fails it returns a null pointer and the caller can check for that, but when it fails for … Read more
The dynamic_cast<void*>() can indeed be used to check for identity, even if dealing with multiple inheritance. Try this code: #include <iostream> class B { public: virtual ~B() {} }; class D1 : public B { }; class D2 : public B { }; class DD : public D1, public D2 { }; namespace { bool … Read more
Yes it is possible using Reflection Object something = “something”; String theType = “java.lang.String”; Class<?> theClass = Class.forName(theType); Object obj = theClass.cast(something); but that doesn’t make much sense since the resulting object must be saved in a variable of Object type. If you need the variable be of a given class, you can just cast … Read more
Here’s a rundown on static_cast<> and dynamic_cast<> specifically as they pertain to pointers. This is just a 101-level rundown, it does not cover all the intricacies. static_cast< Type* >(ptr) This takes the pointer in ptr and tries to safely cast it to a pointer of type Type*. This cast is done at compile time. It … Read more