Как правильно работать с std::is_base_of?

#include <iostream>
#include <vector>
 
class A
{
    public:
};
class B : public A
{
    public:
};
class C : public A
{
    public:
};
 
class BAble : public B
{
    public:
};
class CAble : public C
{
    public:
};
 
std :: vector<B*> bv;
std :: vector<C*> cv;
 
template<class T>
void func( T* a )
{
  if( std::is_base_of<B,T> :: value )
    bv.push_back( a );
 
  if( std::is_base_of<C,T> :: value )
    cv.push_back( a );
}
 
 
int main()
{
    BAble* ba = new BAble;
    BAble* ba2 = new BAble;
    CAble* ca = new CAble;    
    
    func( ba );
    func( ba2 );
    func( ca );
}

template <typename T, typename = int>
void foo()
{
    puts(__PRETTY_FUNCTION__);
}
 
int main()
{
    foo<double>();
}

    template<typename T, typename std::enable_if<std::is_base_of<RenderableSystem, T>::value, T>::type* = nullptr>
    T* addSystem()
    {
        T* system = new T();
        _renderableSystems.push_back( system );
        return system;
    }
 
    template<typename T, typename std :: enable_if<std :: is_base_of<LogicalSystem, T> :: value, T> :: type* = nullptr>
    T* addSystem()
    {
        T* system = new T();
        _logicalSystems.push_back( system );
        return system;
    }

    template<typename T, typename = std :: enable_if<std :: is_base_of<RenderableSystem, T> :: value, T>::type>
    T* addSystem()
    {
        T* system = new T();
        _renderableSystems.push_back( system );
        return system;
    }

template<typename, typename>
T* addSystem();
 
template<typename, typename>
T* addSystem();

template<typename, typename std::enable_if<std::is_base_of<LogicalSystem, T>::value>::type>
T* addSystem();
 
template<typename, typename std::enable_if<std::is_base_of<RenderableSystem, T>::value>::type>
T* addSystem();

typename std::enable_if</* ... */>::type * = nullptr

class SystemManager
{
public:
    template<typename T>
    T* addSystem()
    {
        T* system = new T();
        _addSystem(system);
        return system;
    }
 
private:
    void _addSystem(RenderableSystem* system)
    {
        _renderableSystems.push_back(system);
    }
    
    void _addSystem(LogicalSystem* system)
    {
        _logicalSystems.push_back(system);
    }
 
    // ...
};

template<typename T, typename std::enable_if<std::is_base_of<LogicalSystem, T>::value>::type>
T* addSystem();
template<typename T, typename std::enable_if<std::is_base_of<RenderableSystem, T>::value>::type>
T* addSystem();

template<typename T, typename std::enable_if<std::is_base_of<LogicalSystem, T>::value>::type>
T* addSystem();

template<PhysicsSystem, typename std::enable_if<std::is_base_of<LogicalSystem, PhysicsSystem>::value>::type>
PhysicsSystem* addSystem();

template<PhysicsSystem>
PhysicsSystem* addSystem();

template<typename T, typename = std :: enable_if<std :: is_base_of<RenderableSystem, T> :: value, T>::type>
T* addSystem()
{
}

typename = typename std :: enable_if<std :: is_base_of<RenderableSystem, T> :: value, T>::type

template<typename T, typename std::enable_if<std::is_base_of<LogicalSystem, T>::value>::type>
T* addSystem();

template<typename T, typename K = typename std :: enable_if<std :: is_base_of<RenderableSystem, T> :: value, T>::type>
T* addSystem();

T* addSystem<T, void>();