#include <typeinfo>, что такое typeid()

namespace std
{
  /**
   *  @brief  Part of RTTI.
   *
   *  The @c type_info class describes type information generated by
   *  an implementation.
  */
  class type_info
  {
  public:
    /** Destructor first. Being the first non-inline virtual function, this
     *  controls in which translation unit the vtable is emitted. The
     *  compiler makes use of that information to know where to emit
     *  the runtime-mandated type_info structures in the new-abi.  */
    virtual ~type_info();
 
    /** Returns an @e implementation-defined byte string; this is not
     *  portable between compilers!  */
    const char* name() const
    { return __name[0] == '*' ? __name + 1 : __name; }
 
#if !__GXX_TYPEINFO_EQUALITY_INLINE
    // In old abi, or when weak symbols are not supported, there can
    // be multiple instances of a type_info object for one
    // type. Uniqueness must use the _name value, not object address.
    bool before(const type_info& __arg) const;
    bool operator==(const type_info& __arg) const;
#else
  #if !__GXX_MERGED_TYPEINFO_NAMES
    /** Returns true if @c *this precedes @c __arg in the implementation's
     *  collation order.  */
    // Even with the new abi, on systems that support dlopen
    // we can run into cases where type_info names aren't merged,
    // so we still need to do string comparison.
    bool before(const type_info& __arg) const
    { return (__name[0] == '*' && __arg.__name[0] == '*')
    ? __name < __arg.__name
    : __builtin_strcmp (__name, __arg.__name) < 0; }
 
    bool operator==(const type_info& __arg) const
    {
      return ((__name == __arg.__name)
          || (__name[0] != '*' &&
          __builtin_strcmp (__name, __arg.__name) == 0));
    }
  #else
    // On some targets we can rely on type_info's NTBS being unique,
    // and therefore address comparisons are sufficient.
    bool before(const type_info& __arg) const
    { return __name < __arg.__name; }
 
    bool operator==(const type_info& __arg) const
    { return __name == __arg.__name; }
  #endif
#endif
    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    size_t hash_code() const noexcept
    {
#  if !__GXX_MERGED_TYPEINFO_NAMES
      return _Hash_bytes(name(), __builtin_strlen(name()),
             static_cast<size_t>(0xc70f6907UL));
#  else
      return reinterpret_cast<size_t>(__name);
#  endif
    }
#endif // __GXX_EXPERIMENTAL_CXX0X__
 
    // Return true if this is a pointer type of some kind
    virtual bool __is_pointer_p() const;
 
    // Return true if this is a function type
    virtual bool __is_function_p() const;
 
    // Try and catch a thrown type. Store an adjusted pointer to the
    // caught type in THR_OBJ. If THR_TYPE is not a pointer type, then
    // THR_OBJ points to the thrown object. If THR_TYPE is a pointer
    // type, then THR_OBJ is the pointer itself. OUTER indicates the
    // number of outer pointers, and whether they were const
    // qualified.
    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
                unsigned __outer) const;
 
    // Internally used during catch matching
    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
                 void **__obj_ptr) const;
 
  protected:
    const char *__name;
 
    explicit type_info(const char *__n): __name(__n) { }
 
  private:
    /// Assigning type_info is not supported.
    type_info& operator=(const type_info&);
    type_info(const type_info&);
  };

void lightParticle::Collied(std::unique_ptr<Particle>& obj) {
    const std::type_info& objType = typeid(obj);
    if (objType == typeid(lightParticle)) {                <-- это не срабатывает
        this->set_VX_VY(obj->getVX(), obj->getVX());
        obj->set_VX_VY(this->getVX(), this->getVX());
        std::cout << "YESSIR!";
    }
    else if (typeid(obj).name() == "heavyParticle") {
        std::cout << "ERROR";
        /* code */
    }
    std::cout << "OHMY"; // <-- это срабатывает
};

const std::type_info& objType = typeid(obj.element_type);

const std::type_info& objType = typeid(std::unique_ptr<Particle>::element_type);

assert(obj);
const std::type_info& objType = typeid(*obj);
if (objType.hash_code() == typeid(lightParticle).hash_code())

const std::type_info& objType = typeid(std::unique_ptr<Particle>::element_type);