自学教程：C++ type_info函数代码示例

  Object* Class::set_superclass(STATE, Object* obj) {    if(obj->nil_p()) {      superclass(state, nil<Class>());      return cNil;    }    Class* sup = try_as<Class>(obj);    if(!sup) {      return Primitives::failure();    }    if(try_as<SingletonClass>(sup)) {      Exception::raise_type_error(state, "cannot inherit from a singleton class");    }    superclass(state, sup);    instance_type(state, sup->instance_type());    if(sup->type_info()->type == PackedObject::type) {      type_info(state->memory()->type_info[ObjectType]);    } else {      type_info(sup->type_info());    }    SingletonClass::attach(state, this, sup->singleton_class(state));    sup->track_subclass(state, this);    return cNil;  }

  Object* Class::allocate(STATE) {    Object* obj = cNil;    object_type obj_type = type_info()->type;    if(obj_type == PackedObject::type) {      obj = allocate_packed(state, this);    } else if(!type_info()->allow_user_allocate || kind_of<SingletonClass>(this)) {      std::ostringstream msg;      msg << "direct allocation disabled for ";      if(kind_of<SingletonClass>(this)) {         msg << to_string(state);      } else {         msg << module_name()->debug_str(state);      }      Exception::raise_type_error(state, msg.str().c_str());    } else if(obj_type == Object::type) {      auto_pack(state);      obj = allocate_packed(state, this);    } else {      // type_info()->type is neither PackedObject nor Object, so use the      // generic path.      obj = state->memory()->new_object<Object>(          state, this, type_info()->instance_size, obj_type);    }#ifdef RBX_ALLOC_TRACKING    if(unlikely(state->vm()->allocation_tracking())) {      new_obj->setup_allocation_site(state);    }#endif    return obj;  }

 InOutParameter (Path const& path,                 unsigned long line,                 std::string const& name)     : Node (path, line), Parameter (name) {   type_info (static_type_info ()); }

 ReadWriteAttribute (Path const& path, unsigned long line)     : Node (path, line),       ReadAttribute (path, line),       WriteAttribute (path, line) {   type_info (static_type_info ()); }

/* * Free a type, this 'backs up' the pointer to get back to the p3dc_NODE * structure, verifies that we are in fact the correct NODE for this * type and then adds the type back into the Pool of free structures. */voidp3dc_free_type(void *payload) {	p3dc_NODE *n;	struct tinfo *ti;	__free_type_called++;	if (payload == NULL)		return;	n = (void *)(((char *)payload) - NODE_SIZE);	if (n->data.p != payload)		return;	/* Can't free "unknown" types */	if (n->data.t == P3DC_UNKNOWN) 		return; 	ti = type_info(n->data.t);	if (ti == NULL) {		__free_no_type++;		return; /* wasn't a recognized type (could be an assert)*/	}	ti->stats.frees++;	/* n->owner != NULL means it is already on the free list! */	assert(n->owner == NULL); 	p3dc_add_node(ti->pool, n, P3DC_LIST_HEAD);}

 IntOr (Path const& path, unsigned long line)     : Node (path, line),       first_pattern_ (0),       second_pattern_ (0) {   type_info (static_type_info ()); }

 IntLiteral (Path const& path,             unsigned long line,             unsigned long long value)     : Node (path, line), value_ (value) {   type_info (static_type_info ()); }

 IntSub (Path const& path, unsigned long line)     : Node (path, line),       minuend_ (0),       subtrahend_ (0) {   type_info (static_type_info ()); }

 IntLsh (Path const& path, unsigned long line)     : Node (path, line),       pattern_ (0),       factor_ (0) {   type_info (static_type_info ()); }

 IntAdd (Path const& path, unsigned long line)     : Node (path, line),       first_item_ (0),       second_item_ (0) {   type_info (static_type_info ()); }

 IntMul (Path const& path, unsigned long line)     : Node (path, line),       first_factor_ (0),       second_factor_ (0) {   type_info (static_type_info ()); }

 IntRem (Path const& path, unsigned long line)     : Node (path, line),       divident_ (0),       divisor_ (0) {   type_info (static_type_info ()); }

/* * Allocate a new P3DC Type structure. * * This code first checks to see if the pool of free structures * of this type has any available structures, if so it returns * one, else it allocates one. */void *p3dc_new_type(p3dc_TYPE t) {	p3dc_NODE	*r;	struct tinfo *ti = type_info(t);	__new_type_called++;	if (ti == NULL)		return NULL;	assert(ti->pool->n_type == t);	ti->stats.allocs++;	if (ti->pool->head != NULL) {		r = p3dc_remove_node(ti->pool, P3DC_NODE_FIRST);	} else {		__new_forced_malloc++;		r = (p3dc_NODE *)malloc(NODE_SIZE + ti->size);		r->data.p = ((char *) r) + NODE_SIZE;		r->data.t = t;		r->owner = NULL;		r->name = NULL;		r->nxt = r->prv = NULL;		r->parent = NULL;	}	return (r->data.p);}

 static inline PyTypeObject* get_derived_class_object(boost::python::detail::true_, U const volatile* x) {     converter::registration const* r = converter::registry::query(         type_info(typeid(*get_pointer(x)))     );     return r ? r->m_class_object : 0; }

Var Interpreter::update_Callable( Var callable, Var varargs ) {    // -> new Callable[ surdef_list, self_type, parm_type ]    TypeInfo *type = type_info( callable.type_expr() );    if ( isa_Void( type->parameters[ 2 ] ) ) {        // -> no previously defined parms        Expr n_data = concat( callable.expr(), pointer_on( varargs.expr() ) );        Var varargs_type = type_of( varargs );        // -> Callable[ surdef_list, self_type, parm_type ]        Var *parms[ 3 ];        parms[ 0 ] = &type->parameters[ 0 ];        parms[ 1 ] = &type->parameters[ 1 ];        parms[ 2 ] = &varargs_type;        Var res( type_for( class_info( class_Callable ), parms ), n_data );        res.add_ref_from( callable );        res.add_ref( callable.expr().size_in_bits(), varargs );        return res;    }    //    PRINT( type->parameters[ 2 ] );    TODO;    return error_var;}

 EventTypeFactory (Path const& path, unsigned long line)     : Node (path, line),       TwoWayOperation (path, line),       ValueTypeFactory (path, line) {   type_info (static_type_info ()); }

ContentControl::ContentControl (){	SetContentSetsParent (true);	SetObjectType (Type::CONTENTCONTROL);	ManagedTypeInfo type_info (GetObjectType (), "System.Windows.Controls.ContentControl");	SetDefaultStyleKey (&type_info);}

void register_type(const std::type_info& Info, const string_t& Name){	if(type_to_name_map.count(type_info(Info)))	{		k3d::log() << error << k3d_file_reference << ": attempt to re-register type [" << demangle(Info) << "] with existing name [" << type_to_name_map[type_info(Info)] << "] under new name [" << Name << "]" << std::endl;		return;	}	if(type_to_name_map.count(type_info(Info)) || name_to_type_map.count(Name))	{		k3d::log() << error << k3d_file_reference << ": attempt to register new type [" << demangle(Info) << "] using existing name [" << Name << "]" << std::endl;		return;	}	type_to_name_map.insert(std::make_pair(type_info(Info), Name));	name_to_type_map.insert(std::make_pair(Name, type_info(Info)));}

inline type_info type_id(){    return type_info(#  if !defined(_MSC_VER)                                       /      || !BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700)        typeid(T)#  else // strip the decoration which Intel mistakenly leaves in        python::detail::msvc_typeid((geofeatures_boost::type<T>*)0)#  endif         );}

inline type_info type_id(BOOST_EXPLICIT_TEMPLATE_TYPE(T)){    return type_info(#  if !defined(_MSC_VER)                                       /      || (!BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                /          && !BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700))        typeid(T)#  else // strip the decoration which msvc and Intel mistakenly leave in        python::detail::msvc_typeid((boost::type<T>*)0)#  endif         );}

 virtual void connect(SimObjPtr s, bool) {     auto portOut = dynamic_cast<SimMemoryTemplate<T> *>(s);     if (type_info(nullValue) == portOut->getMemoryTypeInfo()) {         sourcePorts.push_back(new SourcePort(portOut, portOut->getCurrentValuePtr()));         portOut->incrementFanOut();     } else {         std::cout << "*** Source/sink port value type mismatch, "         << "source: " << s->getFullName()         << ", sink: " << getFullName()         << " ***" << std::endl;     } }

 AnyType () {   type_info (static_type_info ()); }

 AnyUri (void) {   type_info (static_type_info ()); }

 NormalizedString () {   type_info (static_type_info ()); }

 AnySimpleType () {   type_info (static_type_info ()); }

 Href () {   type_info (static_type_info ()); }

 QName () {   type_info (static_type_info ()); }

 NMTOKEN () {   type_info (static_type_info ()); }

 Token () {   type_info (static_type_info ()); }