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

List *quick_sort(List *list){    int count = List_Node_count(list);    if(count==1 || count==0)    {        return list;    }    List *lesser = List_create();    List *greater = List_create();    Node *pivot = list->first;    Node *current = pivot->next;    Node *to_push;    while(current!=NULL)    {        to_push = current;        current = current->next;        to_push->previous = NULL;        to_push->next = NULL;        if(to_push->data<pivot->data)        {            List_push(lesser, to_push);        }        else        {            List_push(greater, to_push);        }    }    pivot->next = NULL;    pivot->previous = NULL;    return concatenate(quick_sort(lesser), pivot, quick_sort(greater));}

char *test_push_pop(){    List_push(list, test1);    mu_assert(List_last(list) == test1, "Wrong last value");    List_push(list, test2);    mu_assert(List_last(list) == test2, "Wrong last value");    List_push(list, test3);    mu_assert(List_last(list) == test3, "Wrong last value");    mu_assert(List_count(list) == 3, "Wrong count on push");    char *val = List_pop(list);    mu_assert(val == test3, "Wrong value on pop");    val = List_pop(list);    mu_assert(val == test2, "Wrong value on pop");    val = List_pop(list);    mu_assert(val == test1, "Wrong value on pop");    mu_assert(List_count(list) == 0, "Wrong count after pop.");    return NULL;}

List *List_merge_sort(List *list, List_compare cmp){	// 未初始化的List，视为不能排序	if(list == NULL) return NULL;	// 空List和只有一个节点的List视为已经排序	if(List_count(list) < 2) return list;	int i = 1;	ListNode *cur = list->first;	List *left = List_create();	List *right= List_create();	int middle = List_count(list) / 2;	// 拆成两个List，分别排序	for(i = 1; i < middle; i++)	{		List_push(left, cur->value);		cur=cur->next;	}	for(i = 1; i <= List_count(list) - middle; i++)	{		List_push(right, cur->value);		cur=cur->next;	}	List *sort_left = List_merge_sort(left, cmp);	List *sort_right =	List_merge_sort(right, cmp);	if(sort_left != left) List_destroy(left);	if(sort_right != right) List_destroy(right);		// merge	return List_merge(sort_left, sort_right, cmp);}

List *List_merge_sort(List *list, List_compare cmp){	if(List_count(list)<=1){		return list;	}		List *left=List_create();	List *right=List_create();	int middle=List_count(list)/2;		LIST_FOREACH(list, first, next, cur){		if(middle>0){			List_push(left, cur->value);		} else {			List_push(right, cur->value);		}				middle--;	}		List *sort_left=List_merge_sort(left, cmp);	List *sort_right=List_merge_sort(right, cmp);		if(sort_left !=left) List_destroy(left);	if(sort_right !=right)List_destroy(right);		return List_merge(sort_left, sort_right, cmp);}

List *List_merge(List *left, List *right, List_compare cmp) {	List *result = List_create();	void *val = NULL;	while(List_count(left) != 0 && List_count(right) != 0) {		if(cmp(List_first(left), List_first(right)) <= 0) {			val = List_shift(left);            List_push(result, val);		} else {			val = List_shift(right);            List_push(result, val);		}	}	while(List_count(left) != 0) {		val = List_shift(left);        List_push(result, val);	}	while(List_count(right) != 0) {		val = List_shift(right);		List_push(result, val);	}	return result;}

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);}

char *test_read(){    List_push(list, tv1);    List_push(list, tv2);    List_push(list, tv3);    LIST_ITERATOR(list){        printf("%s/n", current->value);    }    return NULL;}

void str_push_pop(List *list) {    SET_TYPE(list, string);    List_push(list, "hello world");    List_push(list, "bad boy");    assert(strcmp(List_index(list, 0)->data, "hello world") == 0);    assert(strcmp(List_index(list, 1)->data, "bad boy") == 0);    assert(strcmp(List_first(list)->data, "hello world") == 0);    assert(strcmp(List_last(list)->data, "bad boy") == 0);    List_pop(list);    List_pop(list);}

char *test(){    List *list = List_create();    List_push(list, 5);    List_push(list, 4);    List_push(list, 3);    List_push(list, 2);    List_push(list, 1);    List_bubble_sort(list);    return NULL;}

void push_shift(List *list) {    List_push(list, 12);    List_push(list, 7);    List_push(list, 2);    assert(List_index(list, 0)->data == 12);    assert(List_index(list, 1)->data == 7);    assert(List_first(list)->data == 12);    assert(List_last(list)->data == 2);    List_shift(list);    assert(List_first(list)->data == 7);    List_shift(list);    assert(List_first(list)->data == 2);    List_shift(list);    assert(List_first(list) == NULL);}

char* test_copy() {  src = List_create();  dest = List_create();  List_push(src, test1);  List_push(src, test2);  List_push(src, test3);  List_copy(dest, src);  mu_assert(List_count(dest) == 3, "Wrong copy - count.");  mu_assert(List_first(dest) == test1, "Wrong copy - first.");  mu_assert(List_last(dest) == test3, "Wrong copy - last.");  return NULL;}

__declspec(dllexport) void* curl_shim_multi_info_read(void* pvHandle,    int* nMsgs){    // cast return from GetProcAddress as a CPROC    List_T lst = NULL;    CPVPROC pcp = (CPVPROC)GetProcAddress(g_hModCurl,        "curl_multi_info_read");    void* pvItem;    int i, nLocalMsgs, j = 0;    unsigned int *pnReturn = NULL;    unsigned int *pnItem;    *nMsgs = 0;    while ((pvItem = pcp(pvHandle, &nLocalMsgs)) != NULL)        lst = List_push(lst, pvItem);    *nMsgs = List_length(lst);    if (*nMsgs == 0)        return NULL;    pnReturn = (unsigned int*)malloc(3 * (*nMsgs) * sizeof(unsigned int));    for (i = 0; i < (*nMsgs); i++)    {        lst = List_pop(lst, (void**)&pnItem);        pnReturn[j++] = pnItem[0];        pnReturn[j++] = pnItem[1];        pnReturn[j++] = pnItem[2];                }    List_free(&lst);    return pnReturn;}

inline List *List_merge(List *left, List *right, List_val_compare cmp) {    check((left != NULL) || (right != NULL), "Tried to merge NULL.");    List *merged = List_create();    void *val = NULL;    while(List_count(left) > 0 || List_count(right) > 0) {        if(List_count(left) > 0 && List_count(right) > 0) {            if(cmp(List_first(left), List_first(right)) <= 0) {                val = List_fpop(left);            } else {                val = List_fpop(right);            }            List_push(merged, val);        } else if(List_count(left) > 0) {            merged = List_join(merged, left);            break;        } else if(List_count(right) > 0) {            merged = List_join(merged, right);            break;        }    }    return merged;error:    return NULL;}

/* push lines to the line_stack, to be read next - they need to be pushed   in reverse order, i.e. last pushed is next to be retrieved   line may contain multiple lines separated by '/n', they are split and   pushed back-to-forth so that first text is first to retrieve from getline() */void SrcFile_ungetline( SrcFile *self, char *lines ){	char *next_line, *line;	size_t len;	/* search next line after first '/n' */	next_line = search_next_line( lines );	/* recurse to push this line at the end */	if ( next_line )		SrcFile_ungetline( self, next_line );	/* now push this line, add a newline if missing */	len = next_line ? next_line - lines : strlen( lines );	if ( len > 0 && lines[ len - 1 ] == '/n' )		len--;							/* ignore newline */	line = m_malloc( len + 2 );			/* 2 bytes extra for '/n' and '/0' */	strncpy( line, lines, len );	line[ len     ] = '/n';	line[ len + 1 ] = '/0';	List_push( & self->line_stack, line );}

intmain(int argc, char** argv){	if (argc != 3)		print_usage("Invalid parameter count");	Server* server = NULL;	if (strcmp(argv[1], "unix") == 0)		server = (Server*)UnixServer_new("/tmp/echo.sock");	else if (strcmp(argv[1], "tcp") == 0)		server = (Server*)TCPServer_new("0.0.0.0", 6666);	else		print_usage("Invalid server type");	int worker_count = atoi(argv[2]);	int i;	for (i = 0; i < worker_count; i++)		List_push(server->workers, ConnectionWorker_new(EchoConnection_new, &connection_callbacks));	server->callbacks = &server_callbacks;	Server_start(server);         // blocks}

static List *neighbours_list(World *world, Point *point, Point *destination, Hashmap *nodes){  List *neighbours = List_create();  int nx, ny;  for(nx = point->x - 1; nx <= point->x + 1; nx++) {    if(nx < 0 || nx >= world->width) continue;    for(ny = point->y - 1; ny <= point->y + 1; ny++) {      if(ny < 0 || ny >= world->height ||	 (ny == point->y && nx == point->x) ||	 (!World_can_enter(world, nx, ny, point->z) &&	  !(nx == destination->x && ny == destination->y))) continue;      Point *p  = Point_create(nx, ny, point->z);      Node *node = Node_create(p, 0, 0, NULL);      Node *old_node = Hashmap_get(nodes, node);      if(old_node) {	Node_destroy(node);	node = old_node;      } else {	Hashmap_set(nodes, node, node);      }      List_push(neighbours, node);    }  }  return neighbours;}

List *split_access_get_all_split_sections(char *file_loc){	assert(file_loc != NULL);	FILE *file;	char *chr = NULL;	seq_region_t *reg = NULL;	file = fopen(file_loc,"r");	check(file != NULL,"Error opening split list file.");	char line[250];	int i=0;	List *li = List_create();	while ( fgets(line,sizeof(line),file) != NULL ){		i++;		chr = malloc(sizeof(char) * 250);		check_mem(chr);		int start_zero_based = 0;		int stop = 0;		int chk = sscanf(line,"%s/t%d/t%d",chr,&start_zero_based,&stop);		check(chk==3,"Error parsing split file line number %d: %s.",i,line);		reg = malloc(sizeof(struct seq_region_t));		check_mem(reg);		reg->beg = start_zero_based+1;		reg->end = stop;		reg->chr_name = chr;		List_push(li,reg);	}	return li;error:	if(reg){		if(reg->chr_name) free(reg->chr_name);		free(reg);	}	if(chr) free(chr);	return NULL;}

int main(void){    List *list = NULL;    list = List_create();    // Int Data    int n1 = 1;    int n2 = 2;    int n3 = 3;    List_push(list, &n1);    List_push(list, &n2);    List_push(list, &n3);    List_print(list, Int_printer);    List_destroy(list);}

void List_join(List *left, List *right){    check(left != NULL, "Destination list is NULL");    check(right != NULL, "Source list is NULL");    LIST_FOREACH(right, first, next, cur) {         List_push(left, cur->value);    }

char *test_copy(){  list = List_create();  mu_assert(List_count(list) == 0, "Wrong count before copy.");  List_push(list, test1);  List_push(list, test2);  List_push(list, test3);  List_push(list, test4);  mu_assert(List_count(list) == 4, "Wrong count after push.");  List *copy = List_copy(list);  mu_assert(copy != list, "Copy and list have same address.");  mu_assert(List_count(copy) == 4, "Copy has wrong count.");  return NULL;}

int serial_read(int com, char* out) {	int n = 0;	if (comDataAvailable(com) > 0) {		n = comRead(com, (unsigned char *)__serial_buf, __SERIAL_BUFFER_SIZE);		if (n > 0) {			__serial_buf[n] = '/0';			if (out) {				strcpy(out, __serial_buf);			}			if (recvlst) {				// copy incoming data to recvlst				char* x = strtok(__serial_buf, "/n");				while (x != 0) {					if (strstr(x, "+CIPRD") == x) {						int len = strlen(x);						int k = 7, l = 0, m = 0;						char z1[4], z2[16];						while (l < 2) {							char fc = x[k];							if (x[k] == ',' || x[k] == 0) {								if (l == 0) {									z1[m++] = 0;								}								if (l == 1) {									z2[m++] = 0;								}								l++;								m = 0;								} else {								if (l == 0) {									z1[m++] = x[k];								}								if (l == 1) {									z2[m++] = x[k];								}							}							k++; 						}						int id = (uint8_t)strtol(z1, 0, 10);						int ln = (uint16_t)strtol(z2, 0, 10);						if (ln > 0) {							esp_recv_data *rd = (esp_recv_data*)malloc(sizeof(esp_recv_data));							rd->id = id;							rd->len = ln;							rd->data = (char*)malloc(rd->len+1);							memcpy(rd->data, x+k+2, rd->len);							rd->data[rd->len] = 0;							List_push(recvlst, rd);						} 					}					x = strtok(0, "/n");				}			}		}	}	return n;}

List *create_words() {    int i = 0;    List *words = List_create();    for(i = 0; i < NUM_VALUES; i++) {        List_push(words, values[i]);    }    return words;}

/*-----------------------------------------------------------------------------*   Insert the given text at the current scan position*----------------------------------------------------------------------------*/void SetTemporaryLine( char *line ){	init_module();#if 0	if (*p != '/0')		List_push(&input_stack, m_strdup(p));		/* save current input */#endif	set_scan_buf( line, FALSE );					/* assume not at BOL */}

List *create_words()//creates list 'words' no bigger than NUM_VALUES{    int i = 0;    List *words = List_create();    for(i = 0; i < NUM_VALUES; i++) {        List_push(words, values[i]);    }    return words;}

voidDatadir_avail_maps (FILE *fp, char *user_mapdir, char *genomesubdir, char *fileroot) {  char *mapdir;  struct dirent *entry;  char *filename;  DIR *dp;  List_T maps = NULL;  char **array;  int n, i;  mapdir = Datadir_find_mapdir(user_mapdir,genomesubdir,fileroot);  fprintf(fp,"Available maps in directory %s:/n",mapdir);  if ((dp = opendir(mapdir)) == NULL) {    fprintf(stderr,"Unable to open mapdir %s/n",mapdir);    exit(9);  }  while ((entry = readdir(dp)) != NULL) {    if (entry->d_name[0] != '.') {      filename = (char *) CALLOC(strlen(mapdir)+strlen("/")+strlen(entry->d_name)+1,				 sizeof(char));      sprintf(filename,"%s/%s",mapdir,entry->d_name);            if (Access_file_exists_p(filename) == true) {	FREE(filename);	filename = (char *) CALLOC(strlen(entry->d_name)+1,sizeof(char));	strcpy(filename,entry->d_name);	maps = List_push(maps,(void *) filename);      } else {	FREE(filename);      }    }  }  if (closedir(dp) < 0) {    fprintf(stderr,"Unable to close mapdir %s/n",mapdir);  }  if ((n = List_length(maps)) == 0) {    fprintf(fp,"  (none found)/n");  } else {    array = (char **) List_to_array(maps,NULL);    qsort(array,n,sizeof(char *),strcmp_cmp);    for (i = 0; i < n; i++) {      fprintf(fp,"%s/n",array[i]);      FREE(array[i]);    }    FREE(array);    List_free(&maps);  }  FREE(mapdir);  return;}

List *List_merge_sort(List *list, List_compare *cmp) {    if (list->count == 1) {        List *res = List_create();        List_push(res, list->first->value);        return res;    }    int middle = list->count / 2;    List *l= List_sublist(list, 0, middle);    List *r= List_sublist(list, middle, list->count - middle);    List *left = List_merge_sort(l, cmp);    List *right = List_merge_sort(r, cmp);    List_destroy(l);    List_destroy(r);    ListNode* leftNode = left->first;    ListNode* rightNode = right->first;    List *res = List_create();    while (leftNode != NULL || rightNode != NULL) {        if (leftNode == NULL) {            List_push(res, rightNode->value);            rightNode = rightNode->next;        } else if (rightNode == NULL) {            List_push(res, leftNode->value);            leftNode = leftNode->next;        } else if (cmp(leftNode->value, rightNode->value) < 0) {            List_push(res, leftNode->value);            leftNode = leftNode->next;        } else {            List_push(res, rightNode->value);            rightNode = rightNode->next;        }    }    List_destroy(left);    List_destroy(right);	return res;}

List *List_copy(List *list) {    List_check(list);    List *dest = NULL;    if(list) {        dest = List_create();        check_mem(dest);        LIST_FOREACH(list, first, next, cur) {            List_push(dest, cur->value);        }    }