dynamic_cast < type-id > ( expression )

// dynamic_cast_1.cpp
// compile with: /c
class B { };
class C : public B { };
class D : public C { };

void f(D* pd) {
  C* pc = dynamic_cast<C*>(pd);  // ok: C is a direct base class
                  // pc points to C subobject of pd 
  B* pb = dynamic_cast<B*>(pd);  // ok: B is an indirect base class
                  // pb points to B subobject of pd
}

// dynamic_cast_2.cpp
// compile with: /c /GR
class A {virtual void f();};
class B {virtual void f();};

void f() {
  A* pa = new A;
  B* pb = new B;
  void* pv = dynamic_cast<void*>(pa);
  // pv now points to an object of type A

  pv = dynamic_cast<void*>(pb);
  // pv now points to an object of type B
}

// dynamic_cast_3.cpp
// compile with: /c /GR
class B {virtual void f();};
class D : public B {virtual void f();};

void f() {
  B* pb = new D;  // unclear but ok
  B* pb2 = new B;

  D* pd = dynamic_cast<D*>(pb);  // ok: pb actually points to a D
  D* pd2 = dynamic_cast<D*>(pb2);  // pb2 points to a B not a D
}

// dynamic_cast_clr.cpp
// compile with: /clr
using namespace System;

void PrintObjectType( Object^o ) {
  if( dynamic_cast<String^>(o) )
   Console::WriteLine("Object is a String");
  else if( dynamic_cast<int^>(o) )
   Console::WriteLine("Object is an int");
}

int main() {
  Object^o1 = "hello";
  Object^o2 = 10;

  PrintObjectType(o1);
  PrintObjectType(o2);
}

// dynamic_cast_4.cpp
// compile with: /c /GR
class A {virtual void f();};
class B {virtual void f();};
class D : public B {virtual void f();};

void f() {
  D* pd = new D;
  B* pb = dynamic_cast<B*>(pd);  // first cast to B
  A* pa2 = dynamic_cast<A*>(pb);  // ok: unambiguous
}

// dynamic_cast_5.cpp
// compile with: /c /GR
class A {virtual void f();};
class B : public A {virtual void f();};
class C : public A { };
class D {virtual void f();};
class E : public B, public C, public D {virtual void f();};

void f(D* pd) {
  E* pe = dynamic_cast<E*>(pd);
  B* pb = pe;  // upcast, implicit conversion
  A* pa = pb;  // upcast, implicit conversion
}

// dynamic_cast_6.cpp
// compile with: /c /GR
class A {virtual void f();};
class B : public A {virtual void f();};
class C : public A { };
class D {virtual void f();};
class E : public B, public C, public D {virtual void f();};

void f(D* pd) {
  B* pb = dynamic_cast<B*>(pd);  // cross cast
  A* pa = pb;  // upcast, implicit conversion
}

// dynamic_cast_7.cpp
// compile with: /c /GR
class A {virtual void f();};
class B {virtual void f();};

void f() {
  A* pa = new A;
  B* pb = dynamic_cast<B*>(pa);  // fails at runtime, not safe;
  // B not derived from A
}

// dynamic_cast_8.cpp
// compile with: /GR /EHsc
#include <stdio.h>
#include <iostream>

struct A {
  virtual void test() {
    printf_s("in A\n");
  }
};

struct B : A {
  virtual void test() {
    printf_s("in B\n");
  }

  void test2() {
    printf_s("test2 in B\n");
  }
};

struct C : B {
  virtual void test() {
    printf_s("in C\n");
  }

  void test2() {
    printf_s("test2 in C\n");
  }
};

void Globaltest(A& a) {
  try {
    C &c = dynamic_cast<C&>(a);
    printf_s("in GlobalTest\n");
  }
  catch(std::bad_cast) {
    printf_s("Can't cast to C\n");
  }
}

int main() {
  A *pa = new C;
  A *pa2 = new B;

  pa->test();

  B * pb = dynamic_cast<B *>(pa);
  if (pb)
    pb->test2();

  C * pc = dynamic_cast<C *>(pa2);
  if (pc)
    pc->test2();

  C ConStack;
  Globaltest(ConStack);

  // will fail because B knows nothing about C
  B BonStack;
  Globaltest(BonStack);
}

in C
test2 in B
in GlobalTest

static_cast <type-id> ( expression ) 

// static_cast_Operator.cpp
// compile with: /LD
class B {};

class D : public B {};

void f(B* pb, D* pd) {
  D* pd2 = static_cast<D*>(pb);  // Not safe, D can have fields
                  // and methods that are not in B.

  B* pb2 = static_cast<B*>(pd);  // Safe conversion, D always
                  // contains all of B.
}

// static_cast_Operator_2.cpp
// compile with: /LD /GR
class B {
public:
  virtual void Test(){}
};
class D : public B {};

void f(B* pb) {
  D* pd1 = dynamic_cast<D*>(pb);
  D* pd2 = static_cast<D*>(pb);
}

// static_cast_Operator_3.cpp
// compile with: /LD /GR
typedef unsigned char BYTE;

void f() {
  char ch;
  int i = 65;
  float f = 2.5;
  double dbl;

  ch = static_cast<char>(i);  // int to char
  dbl = static_cast<double>(f);  // float to double
  i = static_cast<BYTE>(ch);
}