Question

I need to write template which generates some code depending on whether template parameter is instance of of some class. The template can be generated for all classes but only in case the class is subclass of other class the code should be executed.

The problem is that function that should be implemented does not receive any instance of the class, so the only thing known is class name. So it is impossible to achieve this with dynamic_cast as it demands instance of the object

template<T>
class A 
{
  void somefunction(void)
  {
     if (T instanceof Foo) then ...
     else ...
  }
}

adding some explanation

class X: public Foo {};
class Y {};

class A<X> {} // special logic is generated
class A<Y> {} // special logic is NOT generated

Answer 1

You can use template specialization or boost::is_base_of from the boost traits library
Or of course write your own traits, but shouldn’t, for you have not mastered templates yet.

Using specialization, you could

template<T>
class A 
{
  void somefunction() {
     // generic version
  }
};
template<>
class A <Foo>
{
  void somefunction() {
     // foo version
  }
};

As always, let me recommend Vandevoorde/Josuttis “C++ Templates: The Complete Guide”.

If you fear code bloat because only one memberfunction out of many needs to be specialized, you can still outsource that function:

template <typename T> struct somefunction_helper {
    static void thatfunction () {
        // generic form
    }
};
template <> struct somefunction_helper<Foo> {
    static void thatfunction () {
        // Foo form
    }
};

template<T>
class A 
{
  void somefunction()  {
     somefunction_helper<T>::thatfunction();
  }
};