#include <iostream>

#include <vector>

using namespace std;

template<class T,class U>

class Conversion

{

private:

    typedef char Small;

    class Big{char dummy[];};

    static Small test(U);

    static Big test(...);

    static T makeT();

public:

    enum{ exists =

        sizeof(test(makeT()))==sizeof(Small) };

    enum{ exists2Way =

        exists && Conversion<U,T>::exists};

    enum{

        sameType=false};

};

template<class T>

class Conversion<T,T>

{

public:

    enum{exists=,exists2Way=,sameType=};

};

#define SUPERSUBCLASS(T,U)\

    (Conversion<const U*,const T*>::exists && \

    !Conversion<const T*,const void*>::sameType)

#define SUPERSUBCLASS_STRICT(T,U)\

    (SUPERSUBCLASS(T,U) && \

    !Conversion<const T,const U>::sameType)

class Shape

{

public:

    virtual void display()

    {

        cout<<"Shape"<<endl;

    }

};

class Circle:public Shape

{

public:

    virtual void display()

    {

        cout<<"Circle()"<<endl;

    }

};

int _tmain(int argc, _TCHAR* argv[])

{

    cout<<Conversion<double,int>::exists<<endl;

    cout<<SUPERSUBCLASS(Shape,Circle)<<endl;

    cout<<SUPERSUBCLASS_STRICT(Shape,Circle)<<endl;

    return ;

}