Dynamic Cast in C++

The casting operator dynamic_cast in C++ is used to change a pointer or reference from one type to another type. A polymorphic type can be safely downcast at runtime using the dynamic_cast operator. The class hierarchy of polymorphic types includes at least one virtual function.

Syntax:

The syntax for using dynamic_cast is as follows:

Where "expression" is the expression that is being cast and "new_type" denotes the type to which the expression is being cast. A pointer or reference to a polymorphic type must be present in the expression.

To confirm that the object being addressed to or referenced is true of the specified new_type, the dynamic_cast operator will perform a runtime type check. The dynamic_cast operator will return a null pointer (for a pointer cast) or throw a std::bad_cast exception (for a reference cast) if the conversion is impossible.

Example:

A code snippet that demonstrates how to use "dynamic_cast" to perform a downcast:

class Animal {
public:
  virtual ~Animal() {}
};

class Dog : public Animal {
public:
  void bark() {
std::cout<< "Woof woof!" <<std::endl;
  }
};

class Cat : public Animal {
public:
  void meow() {
std::cout<< "Meow meow!" <<std::endl;
  }
};

int main() {
  Animal* animalPtr = new Dog;
  Dog* dogPtr = dynamic_cast<Dog*>(animalPtr);
  if (dogPtr != nullptr) {
dogPtr->bark();
  }
  delete animalPtr;
  return 0;
}

Output:

Woof woof!

Explanation:

In this example, we create a hierarchy of classes: Animal, Dog, and Cat. Dog and Cat both inherit from Animal, and Dog has a function called bark, while Cat has a function called meow.

We create a new Dog object in the "main" and assign its address to a pointer of type Animal*. After that, we try to convert an Animal* pointer to a Dog* pointer using dynamics. Because the object pointed to is a Dog object, dynamic_cast succeeds and returns a valid Dog* pointer. After that, we check that the Dog* pointer is not a nullptr (ie, the conversion was successful) and call the dog object's bark function with dogPtr. Finally, we delete the Animal* pointer, which also deletes the Dog object.

Note: Dynamic_cast is only intended for use with polymorphic types and should not be used with non-polymorphic types. Additionally, the use of dynamic_cast should be minimized, as it can be a sign of poor design in the class hierarchy. In general, it's better to use virtual functions and inheritance to achieve the desired behaviour, rather than relying on casting.

Some important points of Dynamic_cast operator are as follows:

dynamic_cast can also be used with references instead of pointers. The syntax is the same as for pointers, except that you replace the pointer notation * with the reference notation &. For example: dynamic_cast(expression).
If dynamic_cast is used to cast a pointer or reference to a class type to a void pointer or reference, it will perform a reinterpret_cast instead of a dynamic_cast.
dynamic_cast can only be used with pointers or references, not with values.
The performance of dynamic_cast can be slower than other types of casts due to the required runtime type checking.
dynamic_cast can only be used with classes that have at least one virtual function in their class hierarchy. This is because the virtual function table (vtable) is used to perform the runtime type check.
dynamic_cast can be used to cast from a derived class to a base class, but it is not recommended. Instead, use static_cast or rely on implicit conversion.
If dynamic_cast is used to cast a null pointer to a pointer type, the result will be a null pointer of the target type.
When using dynamic_cast with pointers, if the cast fails (i.e., the pointer is not of the target type), the result will be a null pointer. It is different from reinterpret_cast, which will perform an unchecked cast that could result in undefined behavior.
If the cast fails using dynamic_cast with references, a bad_cast exception will be thrown. Therefore, it's important to use exception handling to catch and handle this exception appropriately.
dynamic_cast can also be used to perform cross-casting, which involves casting between two unrelated classes that share a common base class. For example, suppose you have two classes A and B, both of which inherit from a common base class C. If you have a pointer or reference to an A object and you want to cast it to a B pointer or reference (or vice versa), you can use dynamic_cast. However, this type of casting can be tricky and requires careful consideration of the class hierarchy.
dynamic_cast is a relatively expensive operation, so it should be used effectively in performance-critical code. In some cases, it may be better to use alternative techniques, such as template Meta programming or compile-time polymorphism.