What are some 'good use' examples of dynamic casting?

Question

We often hear/read that one should avoid dynamic casting. I was wondering what would be 'good use' examples of it, according to you?

Edit:

Yes, I'm aware of that other thread: it is indeed when reading one of the first answers there that I asked my question!

Answer 1

This recent thread gives an example of where it comes in handy. There is a base Shape class and classes Circle and Rectangle derived from it. In testing for equality, it is obvious that a Circle cannot be equal to a Rectangle and it would be a disaster to try to compare them. While iterating through a collection of pointers to Shapes, dynamic_cast does double duty, telling you if the shapes are comparable and giving you the proper objects to do the comparison on.

Vector iterator not dereferencable

Answer 2

Here's something I do often, it's not pretty, but it's simple and useful.

I often work with template containers that implement an interface, imagine something like

template<class T> class MyVector : public ContainerInterface ... 

Where ContainerInterface has basic useful stuff, but that's all. If I want a specific algorithm on vectors of integers without exposing my template implementation, it is useful to accept the interface objects and dynamic_cast it down to MyVector in the implementation. Example:

// function prototype (public API, in the header file) void ProcessVector( ContainerInterface& vecIfce );  // function implementation (private, in the .cpp file) void ProcessVector( ContainerInterface& vecIfce) {     MyVector<int>& vecInt = dynamic_cast<MyVector<int> >(vecIfce);      // the cast throws bad_cast in case of error but you could use a     // more complex method to choose which low-level implementation     // to use, basically rolling by hand your own polymorphism.      // Process a vector of integers     ... } 

I could add a Process() method to the ContainerInterface that would be polymorphically resolved, it would be a nicer OOP method, but I sometimes prefer to do it this way. When you have simple containers, a lot of algorithms and you want to keep your implementation hidden, dynamic_cast offers an easy and ugly solution.

You could also look at double-dispatch techniques.

HTH