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

int IoAudioMixer_isActive(IoAudioMixer *self){	return List_size(DATA(self)->sounds) || 	List_size(DATA(self)->soundsToRemove) ||	List_size(DATA(self)->events) ||	List_size(DATA(self)->activeEvents);}

static void dns(Dict* dns, struct Context* ctx, struct Except* eh){    List* servers = Dict_getList(dns, String_CONST("servers"));    int count = List_size(servers);    for (int i = 0; i < count; i++) {        String* server = List_getString(servers, i);        if (!server) {            Except_throw(eh, "dns.servers[%d] is not a string", i);        }        Dict* d = Dict_new(ctx->alloc);        Dict_putString(d, String_CONST("addr"), server, ctx->alloc);        rpcCall(String_CONST("RainflyClient_addServer"), d, ctx, ctx->alloc);    }    List* keys = Dict_getList(dns, String_CONST("keys"));    count = List_size(keys);    for (int i = 0; i < count; i++) {        String* key = List_getString(keys, i);        if (!key) {            Except_throw(eh, "dns.keys[%d] is not a string", i);        }        Dict* d = Dict_new(ctx->alloc);        Dict_putString(d, String_CONST("ident"), key, ctx->alloc);        rpcCall(String_CONST("RainflyClient_addKey"), d, ctx, ctx->alloc);    }    int64_t* minSigs = Dict_getInt(dns, String_CONST("minSignatures"));    if (minSigs) {        Dict* d = Dict_new(ctx->alloc);        Dict_putInt(d, String_CONST("count"), *minSigs, ctx->alloc);        rpcCall(String_CONST("RainflyClient_minSignatures"), d, ctx, ctx->alloc);    }}

static void getSomething(Dict* args,                         struct RouteGen_admin_Ctx* ctx,                         String* txid,                         struct Allocator* requestAlloc,                         Dict* genRoutes){    int page = getIntVal(args, String_CONST("page"));    List* routes;    if (getIntVal(args, String_CONST("ip6"))) {        routes = Dict_getList(genRoutes, String_CONST("ipv6"));    } else {        routes = Dict_getList(genRoutes, String_CONST("ipv4"));    }    Assert_true(routes);    List* outList = List_new(requestAlloc);    bool more = false;    for (int i = page * ROUTES_PER_PAGE, j = 0; i < List_size(routes) && j < ROUTES_PER_PAGE; j++) {        String* route = List_getString(routes, i);        Assert_true(route);        List_addString(outList, route, requestAlloc);        if (++i >= List_size(routes)) {            more = false;            break;        }        more = true;    }    Dict* out = Dict_new(requestAlloc);    if (more) {        Dict_putInt(out, String_new("more", requestAlloc), 1, requestAlloc);    }    Dict_putList(out, String_new("routes", requestAlloc), outList, requestAlloc);    Admin_sendMessage(out, txid, ctx->admin);}

int IoList_compare(IoList *self, IoList *otherList){	if (!ISLIST(otherList))	{		return IoObject_defaultCompare(self, otherList);	}	else	{		size_t s1 =  List_size(DATA(self));		size_t s2 =  List_size(DATA(otherList));		size_t i;		if (s1 != s2)		{			return s1 > s2 ? 1 : -1;		}		for (i = 0; i < s1; i ++)		{			IoObject *v1 = LIST_AT_(DATA(self), i);			IoObject *v2 = LIST_AT_(DATA(otherList), i);			int c = IoObject_compare(v1, v2);			if (c)			{				return c;			}		}	}	return 0;}

END_TESTSTART_TEST (test_List_findIf){  List_t *list;  const char *foo = "foo";  const char *bar = "bar";  const char *baz = "baz";  const char *bop = "bop";  List_add(L, (void *) foo);  List_add(L, (void *) bop);  list = List_findIf(L, myPredicate);  fail_unless( list            != NULL );  fail_unless( List_size(list) == 0    );  List_free(list);  List_add(L, (void *) foo);  List_add(L, (void *) bar);  List_add(L, (void *) baz);  List_add(L, (void *) bop);  list = List_findIf(L, myPredicate);  fail_unless( list              != NULL );  fail_unless( List_size(list)   == 2    );  fail_unless( List_get(list, 0) == bar  );  fail_unless( List_get(list, 1) == baz  );  List_free(list);  List_add(L, (void *) baz);  list = List_findIf(L, myPredicate);  fail_unless( list              != NULL );  fail_unless( List_size(list)   == 3    );  fail_unless( List_get(list, 0) == bar  );  fail_unless( List_get(list, 1) == baz  );  fail_unless( List_get(list, 2) == baz  );  List_free(list);}

static void authorizedPasswords(List* list, struct Context* ctx){    uint32_t count = List_size(list);    for (uint32_t i = 0; i < count; i++) {        Dict* d = List_getDict(list, i);        Log_info(ctx->logger, "Checking authorized password %d.", i);        if (!d) {            Log_critical(ctx->logger, "Not a dictionary type %d.", i);            exit(-1);        }        String* passwd = Dict_getString(d, String_CONST("password"));        if (!passwd) {            Log_critical(ctx->logger, "Must specify a password %d.", i);            exit(-1);        }    }    Log_info(ctx->logger, "Flushing existing authorized passwords");    rpcCall(String_CONST("AuthorizedPasswords_flush"), NULL, ctx, ctx->alloc);    for (uint32_t i = 0; i < count; i++) {        Dict* d = List_getDict(list, i);        String* passwd = Dict_getString(d, String_CONST("password"));        Log_info(ctx->logger, "Adding authorized password #[%d].", i);        Dict args = Dict_CONST(            String_CONST("authType"), Int_OBJ(1), Dict_CONST(            String_CONST("password"), String_OBJ(passwd), NULL        ));        struct Allocator* child = ctx->alloc->child(ctx->alloc);        rpcCall(String_CONST("AuthorizedPasswords_add"), &args, ctx, child);        child->free(child);    }}

long Datum_find_(Datum *self, void *delimsList, size_t startIndex) {	List *delims = (List *)delimsList;	List *results = List_new();	size_t i, last = 0;		if (startIndex > self->size) return -1;		for (i = startIndex; i < self->size; i ++)	{		Datum d = Datum_datumAt_(self, i);		size_t j; 				for (j = 0; j < (size_t)List_size(delims); j ++)		{			Datum *delim = (Datum *)List_at_(delims, j);						if (Datum_beginsWith_(&d, delim))			{				return i;			}		}	}		return -1;}

void *Datum_split_(Datum *self, void *delimsList) /* returns a List */{	List *delims = (List *)delimsList;	List *results = List_new();	size_t i, last = 0;		for (i = 0; i < self->size; i ++)	{		Datum d = Datum_datumAt_(self, i);		size_t j; 				for (j = 0; j < (size_t)List_size(delims); j ++)		{			Datum *delim = (Datum *)List_at_(delims, j);						if (Datum_beginsWith_(&d, delim))			{                                List_append_(results, Datum_newFrom_to_(self, last, i));								last = i + delim->size;				i = last - 1; /* since for() will increment it */				break;			}		}	}		if (last != self->size)	{		List_append_(results, Datum_newFrom_to_(self, last, self->size));	}		return results;}

int IoLexer_lex(IoLexer *self){	IoLexer_clear(self);	IoLexer_pushPos(self);	IoLexer_messageChain(self);	if (*(self->current))	{		//printf("Lexing error after: ");		//IoLexer_printLast_(self, 30);		//printf("/n");		if (!self->errorToken)		{			if (List_size(self->tokenStream))			{				self->errorToken = IoLexer_currentToken(self);			}			else			{				self->errorToken = IoLexer_addTokenString_length_type_(self, self->current, 30, NO_TOKEN);			}			IoToken_error_(self->errorToken, "Syntax error near this location");		}		return -1;	}	return 0;}

IoMessage *IoMessage_opShuffle(IoMessage *self, IoObject *locals, IoMessage *m){	Levels *levels = Levels_new(self);	List *expressions = List_new();	List_push_(expressions, self);	while (List_size(expressions) >= 1)	{		IoMessage *n = List_pop(expressions);		do		{			Levels_attach(levels, n, expressions);			List_appendSeq_(expressions, DATA(n)->args);		} while ((n = DATA(n)->next));		Levels_nextMessage(levels);	}	List_free(expressions);	Levels_free(levels);	return self;}

struct EncodingScheme* EncodingScheme_fromList(List* scheme, struct Allocator* alloc){    struct EncodingScheme* list = Allocator_malloc(alloc, sizeof(struct EncodingScheme));    list->count = List_size(scheme);    list->forms = Allocator_malloc(alloc, sizeof(struct EncodingScheme_Form) * list->count);    for (int i = 0; i < (int)list->count; i++) {        Dict* form = List_getDict(scheme, i);        uint64_t* prefixLen = Dict_getInt(form, String_CONST("prefixLen"));        uint64_t* bitCount = Dict_getInt(form, String_CONST("bitCount"));        String* prefixStr = Dict_getString(form, String_CONST("prefix"));        if (!prefixLen || !bitCount || !prefixStr || prefixStr->len != 8) {            return NULL;        }        uint32_t prefix_be;        if (Hex_decode((uint8_t*)&prefix_be, 4, prefixStr->bytes, 8) != 4) {            return NULL;        }        list->forms[i].prefixLen = *prefixLen;        list->forms[i].bitCount = *bitCount;        list->forms[i].prefix = Endian_bigEndianToHost32(prefix_be);    }    if (!EncodingScheme_isSane(list)) {        return NULL;    }    return list;}

void LongNum_multi(LongNum **num1, LongNum **num2, LongNum **result){	node *temp1 = (*num1)->digits;    node *temp2 = (*num2)->digits;    node *temp = NULL;    LongNum *temp1S = LongNum_empty ();    LongNum *temp2S = LongNum_empty ();    LongNum *tempResult = LongNum_empty ();    int curr = 0, fact = 0, i = 0, point = 0;    if (List_size(&(*num1)->digits) > List_size(&(*num2)->digits))	{		while (temp2 != NULL)	    {			fact = temp2->val;		    while (temp1 != NULL)		    {				curr = curr + fact * temp1->val;			    List_additionElement (&temp1S->digits, curr % 10);			    curr = curr / 10;			    temp1 = temp1->next;		    }		    if (curr) List_additionElement (&temp1S->digits, curr);		    LongNum_revert(&temp1S);            for (i = 0; i < curr; i++) (&temp1S->digits, 0);		    LongNum_sum (&temp1S, &temp2S,&tempResult);		    temp = tempResult->digits;		    while (temp != NULL)		    {				fact = (int)*(&temp->val);			    List_additionElement (&(*result)->digits, fact);			    temp = temp->next;		    }		    point = point + 1;		    temp2 = temp2->next;	   }	   temp = temp2S->digits;	   while (temp != NULL)	   {			fact = (int)*(&temp->val);			List_additionElement (&(*result)->digits, fact);			temp = temp->next;	   }    }    return;}

/* Return value negative indicates failure */int Allocate_list(        int           list_size  /* in  */,         LOCAL_LIST_T* local_keys /* out */) {    List_allocated_size(local_keys) = list_size/p;    List_size(local_keys) = list_size/p;    return 0;} /* Allocate_list */

IO_METHOD(IoObject, recycledObjectCount){	/*doc System recycledObjectCount	Returns the current number of objects being held for recycling.	*/	return IONUMBER(List_size(IOSTATE->recycledObjects));}

void IoMessage_assertArgCount_receiver_(IoMessage *self, int n, IoObject *receiver){	if (List_size(DATA(self)->args) < n)	{		IoState_error_(IOSTATE, self, "[%s %s] requires %i arguments/n",					   IoObject_name(receiver), CSTRING(DATA(self)->name), n);	}}

void remove_mid(List *list) {    List_push(list, 12);    List_push(list, 7);    List_push(list, 8);    List_remove(list, List_index(list, 1));    assert(List_size(list) == 2);    assert(List_first(list)->data == 12);    assert(List_last(list)->data == 8);}

IoObject *IoCFFIFunction_call(IoCFFIFunction *self, IoObject *locals, IoMessage *m){	IoCFFILibrary *library;	const char *funName;	void *funPointer, **funArgVals, *funRetVal;	ffi_type **funArgTypes, *funRetType;	ffi_cif *funInterface;	int funArgCount, i;	ffi_status status;	IoObject *returnValAsObj, *funRetTypeObject, *o;	List *funArgTypeObjects;	library = IoObject_getSlot_(self, IOSYMBOL("library"));	funInterface = &(DATA(self)->interface);	funName = CSTRING(IoObject_getSlot_(self, IOSYMBOL("name")));	funPointer = IoCFFILibrary_rawGetFuctionPointer_(library, funName);	funArgTypeObjects = IoList_rawList(IoObject_getSlot_(self, IOSYMBOL("argumentTypes")));	funRetTypeObject = IoObject_getSlot_(self, IOSYMBOL("returnType"));	funArgCount = (int)List_size(funArgTypeObjects);	funArgTypes = calloc(funArgCount, sizeof(ffi_type *));	for (i = 0; i < funArgCount; i++)	{		o = List_at_(funArgTypeObjects, i);		funArgTypes[i] = IoCFFIDataType_ffiType(o);	}	funRetType = IoCFFIDataType_ffiType(funRetTypeObject);	status = ffi_prep_cif(funInterface, FFI_DEFAULT_ABI, funArgCount, funRetType, funArgTypes);	if (status != FFI_OK)	{		printf("/n/nUh oh.  Something went wrong in IoCFFIFunction_call./n/n");		free(funArgTypes);		return IONIL(self);	}	funArgVals = calloc(funArgCount, sizeof(void *));	funRetVal = calloc(1, funRetType->size);	IoState_pushCollectorPause(IOSTATE);	{		for (i = 0; i < funArgCount; i++)		{			o = IoMessage_locals_valueArgAt_(m, locals, i);			funArgVals[i] = IoCFFIDataType_ValuePointerFromObject_(o);		}		ffi_call(funInterface, funPointer, funRetVal, funArgVals);		returnValAsObj = IoCFFIDataType_objectFromData_(funRetTypeObject, funRetVal);	}	IoState_popCollectorPause(IOSTATE);	free(funArgTypes);	free(funArgVals);	free(funRetVal);	return returnValAsObj;}

IoObject *IoAudioMixer_removeAllSounds(IoAudioMixer *self, IoObject *locals, IoMessage *m){	List *sounds = DATA(self)->sounds;	while (List_size(sounds))	{ 		IoAudioMixer_justRemoveSound_(self, List_at_(sounds, 0)); 	}	return self;}

void Get_local_keys(LOCAL_LIST_T* local_keys) {    int i;    /* Seed the generator */    srand(my_rank);    for (i = 0; i < List_size(local_keys);  i++)        Insert_key(rand() % KEY_MOD, i, local_keys);} /* Get_local_keys */

void IoLexer_printTokens(IoLexer *self){	int i;	for (i = 0; i < List_size(self->tokenStream); i ++)	{		IoToken *t = List_at_(self->tokenStream, i);		printf("'%s'", t->name);		printf(" %s ", IoToken_typeName(t));		if (i < List_size(self->tokenStream) - 1)		{			printf(", ");		}	}	printf("/n");}

static intPD_IsMemWriteExpr (Expr expr){  P_memdep_t md;  P_memdep_core_t dep;  md = P_GetMemDep (expr);  assert (List_size (md->deps) > 0);  dep = List_get_first (md->deps);  return (dep->is_def == 1);}

static voidAddExprToList (Expr expr, List * plist){  P_memdep_t md;  md = P_GetMemDep (expr);  if ((List_size (md->deps) > 0))    *plist = List_insert_last (*plist, expr);  return;}

void IoAudioMixer_showEvents(IoAudioMixer *self){	List *events = DATA(self)->events;	int i;	for (i=0; i<List_size(events); i++)	{		printf("%i: ", i);		AudioEvent_show(List_at_(events, i));	}	/*List_do_(events, (ListDoCallback *)AudioEvent_show);*/	printf("/n");}

IoObject *IoThread_threadCount(IoObject *self, IoObject *locals, IoMessage *m){	Thread_Init();	List *threads;	size_t count;	threads = Thread_Threads();	count = List_size(threads);	List_free(threads);	return IONUMBER(count);}

static char* setUser(List* config){    for (int i = 0; i < List_size(config); i++) {        Dict* d = List_getDict(config, i);        if (d) {            String* uname = Dict_getString(d, BSTR("setuser"));            if (uname) {                return uname->bytes;            }        }    }    return NULL;}

static voidcreate_compact_summary(){  effect_t *effect;  int cnt = 0;  local_sum = IPA_cg_cgraph_new(cg->data.fninfo);    effect_list = NULL;  SE_initial_effects();  DEBUG_IPA(2, printf("/nInitial Effects: %d (%d cg nodes)/n",		      List_size(effect_list),		      IPA_htab_size(cg->nodes)););

int Set_equals (T set1, T set2){  T newSet;  List_t p;  Assert_ASSERT(set1);  Assert_ASSERT(set1);  if (List_size (set1->list) != List_size (set2->list))    return 0;  p = List_getFirst (set1->list);  while (p){    Poly_t v = (Poly_t)p->data;    if (List_exists (set2->list, v, set1->equals))      ;     else      return 0;    p = p->next;  }    return 1;}

/* * classify IGNORE * * this is to classify dumb SCC's that we find because we * are not using a pruned SSA * * return 1 if we are classifying */static intClassify_Ignore(PSS_TarSCC scc){    /* you cannot have an SCC with a single node (the mu node)     * cause this does not do anything */    if (List_size(scc->tnode_list) == 1)    {        scc->type = IGNORE;        PSS_PrintSCC(scc);        return 1;    }    return 0;}

int main(int argc, char **argv){  List_t l = List_new();  fprintf(stdout, "test List.../n");  int i;  for (i = 0; i < 100; i++) {    List_addFirst(l, i);  }  fprintf(stdout, "List_getFirst/n");  int r = (int) List_getFirst(l);  assert(r == 99);  fprintf(stdout, "List_getIndexOf/n");  for (i = 0; i < 100; i++) {    r = (int) List_getIndexOf(l, i);    assert(r == (99 - i));  }  fprintf(stdout, "List_addLast/n");  List_addLast(l, 200);  r = (int) List_getIndexOf(l, 100);  assert(r == 200);  fprintf(stdout, "List_size/n");  r = List_size(l);  assert(r == 101);  fprintf(stdout, "List_isEmpty/n");  r = List_isEmpty(l);  assert(r == 0);  List_t l2 = List_new();  r = List_isEmpty(l2);  assert(r == 1);  fprintf(stdout, "List_remove/n");  for (i = 0; i < 100; i++) {    r = (int) List_removeFirst(l);    assert(r == (99 - i));  }  r = (int) List_removeFirst(l);  assert(r == 200);  r = List_isEmpty(l);  assert(r == 1);  return 0;}