Before you start learning what qobject_cast is, you would need to know what C++’s dynamic_cast is. Dynamic cast is all about polymorphism. C++’s dynamic cast uses RTTI (Run Time Type Information) to cast an object. But qobject_cast does this without RTTI. What is dynamic cast? For example suppose we’ve got a car factory function. Like … Read more
1200 dynamic_casts per second is not likely to be a major performance problem. Are you doing one dynamic_cast per image, or a whole sequence of if statements until you find the actual type? If you’re worried about performance, the fastest ways to implement polymorphism are: — fastest — Function overloading (compile-time polymorphism only) CRTP (compile-time … Read more
Reading the standard, in 5.2.7/6 we find that unless the target is an unambiguous base of the source, source must be a polymorphic type. Then in 10.3/1 Virtual functions support dynamic binding and objectoriented programming. A class that declares or inherits a virtual function is called a polymorphic class. In other words the standard doesn’t … Read more
Update The question has been clarified: sorry I was not clear. I want the ownership to remain with original owner, the called function should only get reference to it, not ownership. Not looking for two smart pointer for the same object. In that case, the solution is simply: dynamic_cast<B&>(*my_unique_ptr) Done. It throws if the cast … Read more
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 }
How can the dynamic_cast know whether Derived2 was derived from Derived (what if Derived was declared in a different library)? The answer to that is surprisingly simple: dynamic_cast can know this by keeping this knowledge around. When the compiler generates code it keeps around the data about the class hierarchies in some sort of table … Read more
If you just want to call a function from B you can use one of these: std::shared_ptr<A> ap = …; dynamic_cast<B&>(*ap).b_function(); if (B* bp = dynamic_cast<B*>(ap.get()) { … } In case you actually want to get a std::shared_ptr<B> from the std::shared_ptr<A>, you can use use std::shared_ptr<B> bp = std::dynamic_pointer_cast<B>(ap);
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
§5.2.7/4: If the value of v is a null pointer value in the pointer case, the result is the null pointer value of type R. So you don’t have to check for a null pointer yourself. Same goes for operator delete, deleting a null pointer has no effect.