// conversion de int en char
int i = 100;
char c = static_cast<char>( i );

// conversion de float en int
float f = 100.0f;
i = static_cast<int>( f );

// conversion classes dérivée -> classe parent
class A {};
class B : public A {};

B *b = new B;
A *a = static_cast<A*>( b );

// conversion de int en pointeur de char
int i;
char * ptr = reinterpret_cast<char*>( i );

// conversion de int en référence sur char
char & ref = reinterpret_cast<char&>( i );

// conversion pointeur de char -> pointeur de double
double * ptr2 = reinterpret_cast<double*>( ptr );

class A {};

// conversion de const A * en A *
const A * cptr;
A * ptr = const_cast<A*>( cptr );

// conversion de const A & en A &
A a;
const A & cref = a;
A & ref = const_cast<A&>( cref );

#include <iostream>
#include <string>

class A
{
public:
    virtual std::string get_type() = 0;
};

class B : public A
{
public:
    virtual std::string get_type() { return "B"; }
};

class C : public A
{
public:
    virtual std::string get_type() { return "C"; };
};

A * create_B_or_C()
{
    static int nb = 0;
    // si nb est pair, on crée un B, sinon un C
    ++nb;
    if ( nb % 2 == 0 ) { return new B; }
    return new C;
}

int main()
{
    for ( int i = 0; i < 5; ++i )
    {
        A *a = create_B_or_C();
        std::cout << "Test sur un " << a->get_type() << " : ";

        B *b = dynamic_cast<B*>( a );
        if ( b == 0 )
        {
            // échec du cast en B, il doit s'agir d'un C
            // lève std::bad_cast s'il ne s'agit pas d'un C
            try
            {
                C & c = dynamic_cast<C&>( *a );
                std::cout << "il s'agit d'un C.\n";
            }
            catch ( const std::bad_cast & )
            {
                std::cout << "Oups!\n";
            }
        }
        else
        {
            std::cout << "il s'agit d'un B.\n";
        }
    }
}

// A   B
//  \ /
//   C

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

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

class C : public A, public B
{
};

A *a = new C;
B *b = dynamic_cast<B*>( a );

A *a = new C;
C *c = dynamic_cast<C*>( a ); // downcasting de A en C
B *b = static_cast<B*>( c );  // cast de C en B