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

class B{};

class A
{
public:
  typedef int IAmGood;
};

class B : public A
{
};

class X {};

template <class T> class C
{
public:
  ~C() { typedef T::IAmGood isGood; }
};

int main()
{
  C<A> ca;
  C<B> cb;
  C<X> cx;
  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;
};

class A {
//...
};

class B : public A {
//...
};

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

class A {
//...
};

class B : public A {
//...
};

class E
{
};
template<class T> class C {
//...
public:
~C() { T* ptr_t = NULL; A* ptr_a = ptr_t; //Добавить внятный коментарий}
};

int main(int argc, char** argv)
{
C<A> ca;
C<B> cb;
C<E> ce;//error C2440: 'initializing' : cannot convert from 'class E *' to 'class A *'
//Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast 
//or function-style cast
return 0;
}

template<class T> class C {
//...
АШ>        ~C()
АШ>        {
АШ>             sizeof(static_cast<A*>(reinterpret_cast<T*>(0)));
АШ>        }
}

template C<X>;

class A
{
public:
  typedef int Derived_From_A;
  int a;
};
class B : public A { int b; };
class DA : public A {};
class DB : public B {};

class X : virtual public DA, virtual public DB {};

template <class T> class C
{
public:
  ~C()
  {
    //typedef T::Derived_From_A isGood;
    sizeof(static_cast<A*>(reinterpret_cast<T*>(0)));
  }
};

int main()
{
  C<X> cx;
  return 0;
}

class A {
//...
};

class B : public A {
//...
};

template<class T> class C {
public:
    static void Check() {sizeof(static_cast<A*>(reinterpret_cast<T*>(0)));}
    C() 
    {
         Check();
         //...
    }
};

#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;
}

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
};