#include <TypeManip.h>

class A {
};

class B : public A {
};

template <class T>
class C {
    char check[SUPERSUBCLASS(A, T)];
};

int main(int argc, char* argv[])
{
    C<B> good;
    C<int> bad;
    
    return 0;
}

ЮБ>template <class T>
ЮБ>class C {
ЮБ>    char check[SUPERSUBCLASS(A, T)];
ЮБ>};
ЮБ>

template <class T>
class C {
    typedef char T_should_be_a_subclass_of_A[1][SUPERSUBCLASS(A, T)] COMPILE_TIME_ASSERTION_FOR_C;
};

3.8

4. A program may end the lifetime of any object by reusing the storage which the object occupies or by explicitly calling the destructor for an object of a class type with a non-trivial destructor. For an object of a class type with a non-trivial destructor, the program is not required to call the destructor explicitly before the storage which object occupied is reused or released; however, if there is no explicit call to the destructor or if a delete-expression (5.3.5) is not used to release the storage, the destructor shall not be implicitly called and any program that depends on the side effects produced by the destructor has undefined behavior.

template<class T>
class Checker{
public:
   Checker()
   {
       typedef T* P;
       static_cast<A*>(P());
   }
};

    template<class T, class B> struct Derived_from {
        static void constraints(T* p) { B* pb = p; }
        Derived_from() { void(*p)(T*) = constraints; }
    };

    template<class T1, class T2> struct Can_copy {
        static void constraints(T1 a, T2 b) { T2 c = a; b = a; }
        Can_copy() { void(*p)(T1,T2) = constraints; }
    };

    template<class T1, class T2 = T1> struct Can_compare {
        static void constraints(T1 a, T2 b) { a==b; a!=b; a<b; }
        Can_compare() { void(*p)(T1,T2) = constraints; }
    };

    template<class T1, class T2, class T3 = T1> struct Can_multiply {
        static void constraints(T1 a, T2 b, T3 c) { c = a*b; }
        Can_multiply() { void(*p)(T1,T2,T3) = constraints; }
    };

    typedef char T_should_be_a_subclass_of_A[1][SUPERSUBCLASS(A, T)] COMPILE_TIME_ASSERTION_FOR_C;

    typedef char T_should_be_a_subclass_of_A[1][SUPERSUBCLASS(A, T)];

ГА>class A {
ГА>//...
ГА>};

ГА>class B : public A {
ГА>//...
ГА>};

ГА>template<class T> class C {
ГА>//...
ГА>}
ГА>

template<class Potomok, class Predok>
class isDerived
{
private:

//Определение не требуется
  static char    discriminator(...);
  static double  discriminator(Predok*);
  static Potomok* d;

public:

  enum { value = ( sizeof(discriminator(d)) != sizeof(char) ) };
};


#define IS_DERIVED(Potomok, Predok) isDerived< Potomok, Predok >::value


//Ваш случай.
template<class T> class C 
{

private:
    #ifdef _DEBUG
        char blocker[IS_DERIVED(T, A)];
    #endif
};