Специализации шаблона функции или перезагрузка

#include <iostream>
#include <vector>
using namespace std;
 
class A {};
vector<A*> List;
 
class B : public A
{
public:
    virtual void printB()
    {
        cout << "B" << endl;
    }
};
 
class B2 : public B
{
    void printB()
    {
        cout << "B2" << endl;
    }
};
class C : public A
{
public:
    virtual void printC()
    {
        cout << "C" << endl;
    }
};
class C2 : public C
{
    void printC()
    {
        cout << "C2" << endl;
    }
};
 
template<typename T>
T* AddObj();
 
template<>
B* AddObj<B>()
{
    List.push_back(new B); //Как мне быть если я захочу в массив добавить компонент не B, а B2
    return List[List.size() - 1];
}
 
template<>
C* AddObj<C>()
{
    List.push_back(new C); //Точно так же как и с B
    return List[List.size() - 1];
}

template<typename T>
T* AddObj()
{
    List.push_back(new T);
    return &List.back();
}

#include <iostream>
#include <vector>
using namespace std;
 
class B
{
public:
    virtual void printB()
    {
        cout << "B" << endl;
    }
};
 
class B2 : public B
{
public:
    void printB()
    {
        cout << "B2" << endl;
    }
};
class C
{
public:
    virtual void printC()
    {
        cout << "C" << endl;
    }
};
 
class C2 : public C
{
public:
    void printC()
    {
        cout << "C2" << endl;
    }
};
 
vector<B*> ListB;
vector<C*> ListC;
 
 
template<typename T>
T* AddObj();
 
template<>
B* AddObj<B>()
{
    ListB.push_back(new B); //Как мне быть если я захочу в массив добавить компонент не B, а B2
    return ListB.back();
}
 
template<>
C* AddObj<C>()
{
    ListC.push_back(new C); //Точно так же как и с B
    return ListC.back();
}
int main()
{
    B2* TempB2;
    C2* TempC2;
    TempB2 = AddObj<B2>();
    TempC2 = AddObj<C2>();
 
    TempB2->printB();
    TempC2->printC();
 
    return 0;
}

template<class T>
std::enable_if_t<std::is_base_of<A, T>::value, A*> addObj()
{...ListA}
template<class T>
std::enable_if_t<std::is_base_of<B, T>::value, B*> addObj()
{...ListB}

template<typename Base>
class Storage
{
        template<typename T> 
        std::shared_ptr<T>  append();
 
    private:
        std::vector<std::shared_ptr<Base> >  objs_;
};

Storage<BaseX, DerivedX1, DerivedX2, DerivedX3>   StorageX;
 
DerivedX1* dx1 = StorageX.append<DerivedX1>();
DerivedX2* dx2 = StorageX.append<DerivedX2>();
DerivedX3* dx3 = StorageX.append<DerivedX3>();
 
Storage<BaseY, DerivedY1, DerivedY2>   StorageY;
DerivedY1* dy1 = StorageY.append<DerivedY1>();
// ...