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

bool Player::setIntByHash(uint16_t propHash, LevelObjValue value, const Level* level) noexcept{	switch (propHash)	{	case str2int16("strength"):		strength = std::clamp(value, 0, Class()->MaxStrength());		break;	case str2int16("magic"):		magic = std::clamp(value, 0, Class()->MaxMagic());		break;	case str2int16("dexterity"):		dexterity = std::clamp(value, 0, Class()->MaxDexterity());		break;	case str2int16("vitality"):		vitality = std::clamp(value, 0, Class()->MaxVitality());		break;	case str2int16("lifeDamage"):		lifeDamage = std::max(value, 0);		break;	case str2int16("manaDamage"):		manaDamage = std::max(value, 0);		break;	default:		return false;	}	updateNameAndDescr = true;	return true;}

Variable environment_variable_get(Scope* scope, Variable variable){    for(unsigned int v = 0; v < scope->variables.size(); v++){        if( (scope->variables[v].name == variable.name or variable.name==IGNORE)        and (scope->variables[v].type.name == variable.type.name or variable.type.name==IGNORE)){            return scope->variables[v];        }    }    if(scope->parent == NULL){        #ifdef DEV_ERRORS        fail(DEV_BLANK_TYPE);        #endif // DEV_ERRORS        return Variable("", Class(), false, false);    }    if(environment_variable_exists(scope->parent, variable)){        return environment_variable_get(scope->parent, variable);    }    #ifdef DEV_ERRORS    fail(DEV_BLANK_TYPE);    #endif // DEV_ERRORS    return Variable("", Class(), false, false);}

void connectPrereqsToTargets(const std::string & s, Graph & g) {    auto it = s.begin();    std::set<Class>::iterator targetIt;    while (it != s.end()) {        if (*it == ':') {            std::string target(s.begin(), it);            targetIt = g.classes.find(Class(target));            assert(targetIt != g.classes.end());            ++it;            break;        }        ++it;    }    while (it != s.end()) {        ++it;        auto endit = it;        while (endit != s.end() && *endit != ' ') { ++endit; }        std::string prereq(std::string(it, endit));        std::set<Class>::iterator prereqIt =            g.classes.find(Class(prereq));        assert(prereqIt != g.classes.end());        g.connect(targetIt, prereqIt);        it = endit;    }}

static at *call_method(at *obj, struct hashelem *hx, at *args){   at *fun = hx->function;   assert(FUNCTIONP(fun));      if (Class(fun) == de_class) {      // DE      at *p = eval_arglist(args);      return with_object(obj, fun, p, hx->sofar);   } else if (Class(fun) == df_class) {      // DF      return with_object(obj, fun, args, hx->sofar);   } else if (Class(fun) == dm_class) {      // DM      at *p = new_cons(new_cons(fun, args), NIL);      at *q = with_object(obj, at_mexpand, p, hx->sofar);      return eval(q);         } else {      // DX, DY, DH      at *p = new_cons(fun, new_cons(obj, args));      return Class(fun)->listeval(fun, p);   }}

void lush_delete(at *p){   if (!p || ZOMBIEP(p))      return;   class_t *cl = classof(p);   if (cl->dontdelete)      error(NIL, "cannot delete this object", p);      run_notifiers(p);      if (cl->has_compiled_part) {      assert(isa(p, object_class));      /* OO objects may have two parts          */      /* lush_delete has to delete both of them */      object_t *obj = Mptr(p);      struct CClass_object *cobj = obj->cptr;      oostruct_dispose(obj);      cobj->Vtbl->Cdestroy(cobj);         } else {      if (Class(p)->dispose)         Mptr(p) = Class(p)->dispose(Mptr(p));      else         Mptr(p) = NULL;   }   zombify(p);}

bool Player::hasMaxStats() const noexcept{	return (strength >= Class()->MaxStrength() &&		magic >= Class()->MaxMagic() &&		dexterity >= Class()->MaxDexterity() &&		vitality >= Class()->MaxVitality());}

Header* Header_new(ProcessList* pl) {   Header* this = calloc(1, sizeof(Header));   this->leftMeters = Vector_new(Class(Meter), true, DEFAULT_SIZE);   this->rightMeters = Vector_new(Class(Meter), true, DEFAULT_SIZE);   this->margin = true;   this->pl = pl;   return this;}

static const char *generic_name(at *p){   if (Class(p)->classname)      sprintf(string_buffer, "::%s:%p", NAMEOF(Class(p)->classname),Mptr(p));   else      sprintf(string_buffer, "::%p:%p", Class(p), Mptr(p));      return mm_strdup(string_buffer);}

bool environment_generic_method_exists(TokenContext context, Scope* scope, Method method, Class actual_class, Class generic_class){    for(size_t i = 0; i < scope->methods.size(); i++){        if( (scope->methods[i].name == method.name or method.name==IGNORE)        and (scope->methods[i].parent == method.parent or method.parent==NULL)        and (context_class_compare(context, Class(scope->methods[i].return_type), Class(method.return_type)) or method.return_type == IGNORE_CLASS)        and (generic_arguments_equal(context, scope->methods[i].arguments, method.arguments, actual_class, generic_class))){            return true;        }    }    return false;}

/* linux driver says the release id is not always right */static intheuristicid(uint32_t csp, uint32_t maxpkt){	if(Class(csp) == 0x02)		return TypeH;	else if(maxpkt == 0x40)		return TypeHX;	else if(Class(csp) == 0x00 || Class(csp) == 0xFF)		return TypeH;	else{		fprint(2, "serial: chip unknown, setting to HX version/n");		return TypeHX;	}}

void Component::classes(void){	class_(Component::StencilType, Class(		"Stencil",		Stencil::page,		Stencil::request,		Stencil::call	));	class_(Component::ThemeType, Class(		"Theme",		Theme::page,		nullptr,		Theme::call	));}

Method environment_method_get(TokenContext context, Scope* scope, Method method){    for(size_t i = 0; i < scope->methods.size(); i++){        if( (scope->methods[i].name == method.name or method.name==IGNORE)        and (scope->methods[i].parent == method.parent or method.parent==NULL)        and (context_class_compare(context, Class(scope->methods[i].return_type), Class(method.return_type)) or method.return_type == IGNORE_CLASS)        and (arguments_equal(context, scope->methods[i].arguments, method.arguments))){            return scope->methods[i];        }    }    #ifdef DEV_ERRORS    fail(DEV_BLANK_TYPE);    #endif // DEV_ERRORS    return Method{"", NULL, IGNORE_ARGS, IGNORE_CLASS};}

Variable::Variable(){    name = "";    type = Class("");    is_final = false;    is_static = false;    is_private = false;}

aConfItem	*make_conf(void){	Reg	aConfItem *aconf;	aconf = (struct ConfItem *)MyMalloc(sizeof(aConfItem));#ifdef	DEBUGMODE	aconfs.inuse++;#endif	istat.is_conf++;	istat.is_confmem += sizeof(aConfItem);	bzero((char *)&aconf->ipnum, sizeof(struct IN_ADDR));	aconf->clients = aconf->port = 0;	aconf->next = NULL;	aconf->host = aconf->passwd = aconf->name = aconf->name2 = NULL;#ifdef XLINE	aconf->name3 = NULL;#endif	aconf->ping = NULL;	aconf->status = CONF_ILLEGAL;	aconf->pref = -1;	aconf->hold = time(NULL);	aconf->source_ip = NULL;	aconf->flags = 0L;	Class(aconf) = NULL;	return (aconf);}

/* similar to lush_delete, but don't raise error with permanent objects */void lush_delete_maybe(at *p){   if (p) {      if (!Class(p)->dontdelete)         lush_delete(p);   }}

JSBoolpango::JSContext::Constructor(::JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {    DOC_BEGIN("");    DOC_END;    if (JSA_GetClass(cx,obj) != Class()) {        JS_ReportError(cx,"Constructor for %s  bad object; did you forget a 'new'?",ClassName());        return JS_FALSE;    }    pango::JSContext * myNewObject = 0;    NATIVE * newNative = 0;    if (argc == 0) {        PangoContext * myContext = pango_context_new();        newNative = new NATIVE(myContext, false);    } else {        JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected none () %d",ClassName(), argc);        return JS_FALSE;    }    myNewObject = new pango::JSContext(OWNERPTR(newNative), newNative);    if (myNewObject) {        JS_SetPrivate(cx,obj,myNewObject);        return JS_TRUE;    }    JS_ReportError(cx,"pango::JSContext::Constructor: bad parameters");    return JS_FALSE;}

void Player::updateNameAndDescriptions() const{	if (updateNameAndDescr == true)	{		updateNameAndDescr = false;		if (Class()->getFullName(*this, name) == false &&			name.empty() == true)		{			name = SimpleName();		}		for (size_t i = 0; i < descriptions.size(); i++)		{			Class()->getDescription(i, *this, descriptions[i]);		}	}}

bool Player::setItem(size_t invIdx, size_t itemIdx, std::unique_ptr<Item>& item,	std::unique_ptr<Item>& oldItem){	if (invIdx >= inventories.size())	{		return false;	}	auto itemPtr = item.get();	auto& inventory = inventories[invIdx];	auto ret = inventory.set(itemIdx, item, oldItem);	if (ret == true)	{		if (itemPtr != nullptr)		{			updateItemQuantityCache(itemPtr->Class()->IdHash16());			itemPtr->clearMapPosition();			itemPtr->updateOwner(this);		}		else if (oldItem != nullptr)		{			updateItemQuantityCache(oldItem->Class()->IdHash16());			oldItem->updateOwner(nullptr);		}		if (bodyInventoryIdx == invIdx)		{			updateProperties();		}	}	return ret;}

void UnsupportedProcess_delete(Object* cast) {   Process* this = (Process*) cast;   Object_setClass(this, Class(Process));   Process_done((Process*)cast);   // free platform-specific fields here   free(this);}

JSBoolJSColorSelectionDialog::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {    DOC_BEGIN("");    DOC_END;    ensureParamCount(argc,1,5);    if (JSA_GetClass(cx,obj) != Class()) {        JS_ReportError(cx,"Constructor for %s  bad object; did you forget a 'new'?",ClassName());        return JS_FALSE;    }    NATIVE * newNative = 0;    JSColorSelectionDialog * myNewObject = 0;    if ( argc == 1) {        string myTitle;        convertFrom(cx, argv[0], myTitle);        newNative = new NATIVE(myTitle);    } else {        newNative = new NATIVE();    }    myNewObject = new JSColorSelectionDialog(OWNERPTR(newNative), newNative);    if (myNewObject) {        JS_SetPrivate(cx,obj,myNewObject);        return JS_TRUE;    }    JS_ReportError(cx,"JSColorSelectionDialog::Constructor: failed");    return JS_FALSE;}

void CBaseObject::Allocate(CObjects* pcObjects){	mpcObjectsThisIn = pcObjects;	SetFlag(OBJECT_FLAGS_CALLED_ALLOCATE, TRUE);	Class();	SetDistToStack(UNKNOWN_DIST_TO_STACK);}

JSBoolJSCheckButton::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {    DOC_BEGIN("");    DOC_END;    if (JSA_GetClass(cx,obj) != Class()) {        JS_ReportError(cx,"Constructor for %s  bad object; did you forget a 'new'?",ClassName());        return JS_FALSE;    }    NATIVE * newNative = 0;    JSCheckButton * myNewObject = 0;    if (argc == 0) {        newNative = new Gtk::CheckButton();    } else if (argc == 1) {        Glib::ustring myLabel;        convertFrom(cx, argv[0], myLabel);        newNative = new Gtk::CheckButton(myLabel);    } else {        JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected none () %d",ClassName(), argc);        return JS_FALSE;    }    myNewObject = new JSCheckButton(OWNERPTR(newNative), newNative);    if (myNewObject) {        JS_SetPrivate(cx,obj,myNewObject);        return JS_TRUE;    }    JS_ReportError(cx,"JSCheckButton::Constructor: bad parameters");    return JS_FALSE;}

ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList, uid_t userId) {   int mib[] = { CTL_HW, HW_NCPU };   int fmib[] = { CTL_KERN, KERN_FSCALE };   int i, e;   OpenBSDProcessList* opl = calloc(1, sizeof(OpenBSDProcessList));   ProcessList* pl = (ProcessList*) opl;   size_t size = sizeof(pl->cpuCount);   ProcessList_init(pl, Class(OpenBSDProcess), usersTable, pidWhiteList, userId);   e = sysctl(mib, 2, &pl->cpuCount, &size, NULL, 0);   if (e == -1 || pl->cpuCount < 1) {      pl->cpuCount = 1;   }   opl->cpus = realloc(opl->cpus, pl->cpuCount * sizeof(CPUData));   size = sizeof(fscale);   if (sysctl(fmib, 2, &fscale, &size, NULL, 0) < 0)      err(1, "fscale sysctl call failed");   for (i = 0; i < pl->cpuCount; i++) {      opl->cpus[i].totalTime = 1;      opl->cpus[i].totalPeriod = 1;   }   pageSizeKb = PAGE_SIZE_KB;   // XXX: last arg should eventually be an errbuf   opl->kd = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, NULL);   assert(opl->kd);   return pl;}

JSBoolJSMisc::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {    DOC_BEGIN("");    DOC_END;    if (JSA_GetClass(cx,obj) != Class()) {        JS_ReportError(cx,"Constructor for %s  bad object; did you forget a 'new'?",ClassName());        return JS_FALSE;    }    NATIVE * newNative = 0;    JSMisc * myNewObject = 0;    if (argc == 0) {        newNative = 0;  // Abstract        myNewObject = new JSMisc(OWNERPTR(newNative), newNative);    } else {        JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected none () %d",ClassName(), argc);        return JS_FALSE;    }    if (myNewObject) {        JS_SetPrivate(cx,obj,myNewObject);        return JS_TRUE;    }    JS_ReportError(cx,"JSMisc::Constructor: bad parameters");    return JS_FALSE;}

Panel* Panel_new(int x, int y, int w, int h, bool owner, ObjectClass* type, FunctionBar* fuBar) {   Panel* this;   this = xMalloc(sizeof(Panel));   Object_setClass(this, Class(Panel));   Panel_init(this, x, y, w, h, type, owner, fuBar);   return this;}

AvailableMetersPanel* AvailableMetersPanel_new(Settings* settings, Panel* leftMeters, Panel* rightMeters, ScreenManager* scr) {   AvailableMetersPanel* this = AllocThis(AvailableMetersPanel);   Panel* super = (Panel*) this;   Panel_init(super, 1, 1, 1, 1, Class(ListItem), true);      this->settings = settings;   this->leftPanel = leftMeters;   this->rightPanel = rightMeters;   this->scr = scr;   Panel_setHeader(super, "Available meters");   for (int i = 1; Platform_meterTypes[i]; i++) {      MeterClass* type = Platform_meterTypes[i];      if (type != &CPUMeter_class) {         Panel_add(super, (Object*) ListItem_new(type->uiName, i << 16));      }   }   MeterClass* type = &CPUMeter_class;   int cpus = settings->pl->cpuCount;   if (cpus > 1) {      Panel_add(super, (Object*) ListItem_new("CPU average", 0));      for (int i = 1; i <= cpus; i++) {         char buffer[50];         sprintf(buffer, "%s %d", type->uiName, i);         Panel_add(super, (Object*) ListItem_new(buffer, i));      }   } else {      Panel_add(super, (Object*) ListItem_new("CPU", 1));   }   return this;}

ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList, uid_t userId) {   FreeBSDProcessList* fpl = calloc(1, sizeof(FreeBSDProcessList));   ProcessList* pl = (ProcessList*) fpl;   ProcessList_init(pl, Class(FreeBSDProcess), usersTable, pidWhiteList, userId);   int cpus = 1;   size_t sizeof_cpus = sizeof(cpus);   int err = sysctlbyname("hw.ncpu", &cpus, &sizeof_cpus, NULL, 0);   if (err) cpus = 1;   pl->cpuCount = MAX(cpus, 1);   CPUData* tmp_cpus = (CPUData*) realloc(fpl->cpus, cpus * sizeof(CPUData));   assert(tmp_cpus != NULL);   fpl->cpus = tmp_cpus;   for (int i = 0; i < cpus; i++) {      fpl->cpus[i].totalTime = 1;      fpl->cpus[i].totalPeriod = 1;   }      size_t len;   len = 4; sysctlnametomib("vm.stats.vm.v_wire_count",  MIB_vm_stats_vm_v_wire_count, &len);   len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", MIB_vm_stats_vm_v_cache_count, &len);   len = 2; sysctlnametomib("hw.physmem",                MIB_hw_physmem, &len);   pageSizeKb = PAGE_SIZE_KB;         fpl->kd = kvm_open(NULL, "/dev/null", NULL, 0, NULL);   assert(fpl->kd);   return pl;}

void Player::setDefaultSpeed(const AnimationSpeed& speed_){	defaultSpeed = speed_;	speed = Class()->getSpeed(playerAnimation);	animation.elapsedTime.timeout = speed.animation;	updateSpeed();}