struct Foo
{
};

struct Bar : public Foo
{
};

struct Schmoo
{
};

enum direction
{
    NORTH, SOUTH, EAST, WEST
};

int main()
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // the following statement should not compile if Bar inherited protected or private from Foo
    // Foo* f = new Bar;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Try to cast from base class to derived class
    Foo* f = new Bar;
    Bar* b1 = static_cast<Bar*>(f);
    Bar* b2 = reinterpret_cast<Bar*>(f);

    // This one does not work because there are no virtual functions in Foo
    // Bar* b3 = dynamic_cast<Bar*>(f);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Try to cast from unrelated class pointer
    Schmoo* s2 = reinterpret_cast<Schmoo*>(f);

    // these are not valid
    // Schmoo* s1 = static_cast<Schmoo*>(f);
    // Schmoo* s3 = dynamic_cast<Schmoo*>(f);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Try to cast away constness
    Bar const * b4 = b1;
    Bar* b9 = const_cast<Bar*>(b4);

    // these are not valid
    // Bar* b6 = static_cast<Bar*>(b4);
    // Bar* b7 = dynamic_cast<Bar*>(b4);
    // Bar* b8 = reinterpret_cast<Bar*>(b4);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Try to assign enum to int and int to enum
    direction d = NORTH;
    int i = 0;
    i = d;

    // this one requires a cast
    // d = i;
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Try to cast an int to an enum
    d = static_cast<direction>(i);

    // these are not valid
    // d = reinterpret_cast<direction>(i);
    // d = dynamic_cast<direction>(i);
    // d = const_cast<int>(i);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Try assign pointer to long
    long lng;

    lng = reinterpret_cast<int>(f);

    // these are not valid
    // long lng = f;
    // long lng = static_cast<int>(f);
    // long lng = dynamic_cast<int>(f);
    // long lng = const_cast<int>(f);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Try assign long to pointer
    f = reinterpret_cast<Foo*>(lng);

    // these are not valid
    // f = lng;
    // f = static_cast<Foo*>(lng);
    // f = dynamic_cast<Foo*>(lng);
    // f = const_cast<Foo*>(lng);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    return 0;
}