The dynamic_cast performs a run-time cast that verifies the validity of a cast.

   
// The general form of dynamic_cast: dynamic_cast<target-type> (expr)

// the various situations that dynamic_cast can handle.

#include <iostream>
using namespace std;
   
class Base {
public:
  virtual void f() { cout << "Inside Base\n"; }
};
   
class Derived : public Base {
public:
  void f() { cout << "Inside Derived\n"; }
};
   
int main()
{
  Base *bp, b_ob;
  Derived *dp, d_ob;
   
  dp = dynamic_cast<Derived *> (&d_ob);
  if(dp) {
    cout << "Cast from Derived * to Derived * OK.\n";
    dp->f();
  } else
    cout << "Error\n";
   
  cout << endl;
   
  bp = dynamic_cast<Base *> (&d_ob);
  if(bp) {
    cout << "Cast from Derived * to Base * OK.\n";
    bp->f();
  } else
    cout << "Error\n";
   
  cout << endl;
   
  bp = dynamic_cast<Base *> (&b_ob);
  if(bp) {
    cout << "Cast from Base * to Base * OK.\n";
    bp->f();
  } else
    cout << "Error\n";
   
  cout << endl;
   
  dp = dynamic_cast<Derived *> (&b_ob);
  if(dp)
    cout << "Error\n";
  else
    cout << "Cast from Base * to Derived * not OK.\n";
   
  cout << endl;
   
  bp = &d_ob; // bp points to Derived object
  dp = dynamic_cast<Derived *> (bp);
  if(dp) {
    cout << "Casting bp to a Derived * OK\n" <<
      "because bp is really pointing\n" <<
      "to a Derived object.\n";
    dp->f();
  } else
    cout << "Error\n";
   
  cout << endl;
   
  bp = &b_ob; // bp points to Base object
  dp = dynamic_cast<Derived *> (bp);
  if(dp)
    cout << "Error";
  else {
    cout << "Now casting bp to a Derived *\n" <<
      "is not OK because bp is really \n" <<
      "pointing to a Base object.\n";
  } 
 
  cout << endl;
   
  dp = &d_ob; // dp points to Derived object
  bp = dynamic_cast<Base *> (dp);
  if(bp) {
    cout << "Casting dp to a Base * is OK.\n";
    bp->f();
  } else
    cout << "Error\n"; 
 
  return 0;
}

Related examples in the same category

1.	Don't need a cast to go up the inheritance hierarchy
2.	class type-casting
3.	The const_cast operator is used to explicitly override const and/or volatile in a cast.
4.	Use const_cast on a const reference.
5.	The static_cast operator performs a nonpolymorphic cast.
6.	The reinterpret_cast operator converts one type into a fundamentally different type.
7.	Replacing typeid with dynamic_cast

The dynamic_cast performs a run-time cast that verifies the validity of a cast. : cast « Class « C++

Related examples in the same category