Узнать имя базового класса

template <class Т>
void Components::addComponent(T t) {
// Если t является одной из фигур (шар,куб, и т.д. ), то добавить в массив vector<Figure> figures
// Если t является машиной, то добавить в массив vector<Car> cars
}

#include <iostream>
#include <vector>
 
using namespace std;
 
struct Everything
{
virtual ~Everything(){}
};
 
struct Figure :public Everything
{
 
};
struct Car :public Everything
{
 
};
 
struct EvilTroll :public Everything
{
 
};
 
struct Triangle :public Figure
{
 
};
struct Cube :public Figure
{
 
};
 
struct Ford :public Car
{
 
};
 
struct Vaz :public Car //cry
{
 
};
 
int selector( const Everything &WTFigure )
              {
 
                  if(dynamic_cast<const Car*>(&WTFigure))
                  {
                      return 1;
                  }
 
                  else
                  if(dynamic_cast<const Figure*>(&WTFigure))
                  {
                      return 0;
                  }
                  return -1;
              }
 
int main()
{
vector<Everything*> everything
{
    new Triangle,
    new Cube,
    new Ford,
    new Cube,
    new Vaz,
    new EvilTroll
};
 
int car(0), figure(0), unknown(0);
for(const auto &el:everything)
{
    if(1 == selector(*el))car++;
    if(0 == selector(*el))figure++;
    if(-1 == selector(*el))unknown++;
}
 
cout<<"car= "<< car  << ' '
    <<"figure= "<< figure  << ' '
    <<"unknown= "<< unknown  << ' ' << endl;
 
return 0;
}

// Если t является одной из фигур (шар,куб, и т.д. ), то добавить в массив vector<Figure> figures
// Если t является машиной, то добавить в массив vector<Car> cars
 
// Через if constexpr (C++17)
template <class Т>
void addComponent(T * t) {
    if constexpr(std::is_base_of<Figure, T>::value) {
        figures.push_back(t); // vector<Figure *> figures
    }
    else if constexpr(std::is_base_of<Car, T>::value) {
        cars.push_back(t); // vector<Car *> cars
    }
    // возможно лучше заменить на vector<unique_ptr<Car>> и vector<unique_ptr<Figure>> figures, но это уже вам решать исходя из целей кода
}
 
////////////////////////////
 
 
// Классический подход - перегрузка
void addComponentImpl(Car * t) { // private method
    cars.push_back(t); // vector<Car *> cars
}
void addComponentImpl(Figure * t) { // private method
    figures.push_back(t); // vector<Figure *> figures
}
 
template <class Т>
void addComponent(T * t) {
    addComponentImpl(t);
}

#include <iostream>
#include <vector>
#include <memory>
#include <initializer_list>
 
using namespace std;
 
struct Everything
{
virtual ~Everything(){}
};
 
struct Figure :public Everything
{
 
};
struct Car :public Everything
{
 
};
 
struct EvilTroll :public Everything
{
 
};
 
struct Triangle :public Figure
{
 
};
struct Cube :public Figure
{
 
};
 
struct Ford :public Car
{
 
};
 
struct Vaz :public Car //cry
{
 
};
 
int selector(const unique_ptr<Everything> &WTFigure )
              {
 
                  if(dynamic_cast< Car*>(WTFigure.get()))
                  {
                      return 1;
                  }
 
                  else
                  if(dynamic_cast< Figure*>(WTFigure.get()))
                  {
                      return 0;
                  }
                  return -1;
              }
 
void distributor(
                unique_ptr<Everything> &WTFigure,
                vector<unique_ptr<Car>> &cars,
                vector<unique_ptr<Figure>> &figures
                 )
              {
 
                  if(Car* pcar=dynamic_cast< Car*>(WTFigure.get()))
                  {
                      cars.push_back(unique_ptr<Car>(pcar));
                      WTFigure.release();
                  }
                  else
                  if(Figure* pfig=dynamic_cast< Figure*>(WTFigure.get()))
                  {
                      figures.push_back(unique_ptr<Figure>(pfig));
                      WTFigure.release();
                  }
 
              }
 
template<typename T>
std::vector<T> vector_from(std::initializer_list<T> il)
{
  std::vector<T> result;
  result.reserve(il.size());
  for (auto& e : il)
    result.push_back(std::move(const_cast<T&>(e)));
  return result;
}
 
int main()
{
std::initializer_list<unique_ptr<Everything>> ilist=
{
    unique_ptr<Everything>(new Triangle),
    unique_ptr<Everything>(new Cube),
    unique_ptr<Everything>(new Ford),
    unique_ptr<Everything>(new Cube),
    unique_ptr<Everything>(new Vaz),
    unique_ptr<Everything>(new EvilTroll)
};
vector<unique_ptr<Everything>> everything=vector_from(ilist);
 
int car(0), figure(0), unknown(0);
for(const auto &el:everything)
{
    if(1 == selector(el))car++;
    if(0 == selector(el))figure++;
    if(-1 == selector(el))unknown++;
}
 
cout<<"car= "<< car  << ' '
    <<"figure= "<< figure  << ' '
    <<"unknown= "<< unknown  << ' ' << endl;
 
vector<unique_ptr<Car>> cars;
                vector<unique_ptr<Figure>> figures;
 
for(auto &el:everything)
{
    distributor(el, cars,figures) ;
}
 
cout<<"car= "<< cars.size()  << ' '
    <<"figure= "<< figures.size() <<  endl;
return 0;
}

template <class C>
void Components::addComponent(C component) {    
    if (std::is_base_of< Figure , C>::value == true) {
        figures.push_back(component);
    }
}