Идентификация типов объектов

template<typename Base, typename T>
inline bool instanceof(const T *ptr) {
   return dynamic_cast<const Base*>(ptr) != nullptr;
}

class IteratedPart {
  public:
    virtual int getStatus() = 0;
};
class player:public IteratedPart {
  public:
    virtual int getStatus() {
       if (health>0) return 1;
       else return -1;
    }
};
 
//в коде
foreach(IteratedPart* part: container) {
  if (part->getStatus() != -1) {
      next_container->insert(part);
  }
}

vector <TParent *> Vec;
 
Vec.push_back(new T1());
Vec.push_back(new T2());
Vec.push_back(new T3());

class IteratedPart {
  public:
    virtual int getStatus() = 0;
};
class player:public IteratedPart {
  public:
    virtual int getStatus() {
       return 1;
    }
};
 
//в коде
foreach(IteratedPart* part: container) {
  if (part->getStatus() == 1) {
      next_container->insert(part);
  }
}

template<typename T, typename Base>
inline bool instanceof(const Base *ptr) 
{
  return dynamic_cast<const T *>(ptr) != nullptr;
}

    vector <TParent *> Vec2;
    for(int i = 0; i < q; i++)
    {
       if (dynamic_cast<T1 *>(Vec1[i]) != nullptr)
    {
        Vec2.push_back(Vec1[i]);
    }
    }

#include <cstddef>
#include <utility>
#include <type_traits>
 
// В реальном коде не забудьте про выравнивание
// И про защиту типа
template<size_t N = 32> struct any
{
    template<class t>  any(t&& a) 
    {
        new(buf) t(std::forward<t>(a));
    }
    
    template<class t, class... args>
    t& make(args&&... params)
    {
        auto* p = new(buf) t(std::forward<args>(params)...);
        return *p;
    }
    
    template<class t> operator t() noexcept
    {
        using x = std::remove_reference_t<t>;
        x* p = reinterpret_cast<x*>(this->buf);
        return *p;
    }
   
    char buf[N];
};
 
#include <iostream>
#include <vector>
#include <string>
 
struct IGPIGP
{
    template<class ostream> friend
    ostream& operator<<(ostream& out, const IGPIGP& obj)
    {
        out << "IGPIGP: " << obj.v;
        return out;
    }
    
    int v;
};
 
int main()
{
    std::vector< any<> > container
    {
        std::string{"hello"},
        IGPIGP{1},
        std::string{"world"},
        IGPIGP{2}
    };
    
    std::cout 
        << static_cast<std::string>(container[0]) << '\n'
        << static_cast<IGPIGP>(container[1])      << '\n'
        << static_cast<std::string>(container[2]) << '\n'
        << static_cast<IGPIGP>(container[3])      << '\n';
}