C++ set_init函数代码示例

int main(void) 
{
  set s1, s2;
  int m = 10;

  s1 = set_init(m);
  set_add(s1, 1);
  set_add(s1, 3);
  set_add(s1, 5);
  s2 = set_init(m + 2);
  set_add(s2, 0);
  set_add(s2, 2);
  set_add(s2, 3);
  set_add(s2, 4);
  set_add(s2, 5);
  set_add(s2, 11);
  set_print(s1);
  printf("\n");
  set_print(s2);
  printf("\nIntersection: ");
  set_print(set_intersection(s1, s2));
  printf("\nUnion: ");
  set_print(set_union(s1, s2));
  printf("\nComplement for s2: ");
  set_print(set_complement(s2));
  printf("\n");  
  return 0;
}

QAP_solution_t *ant_build_solution(QAP_t *p){

    int i, j, lct, flt;
    set_t set_lct, set_flt; 
    QAP_solution_t *sol;

    sol = Malloc(sizeof(QAP_solution_t));

    set_init(&set_lct, p->size);
    set_init(&set_flt, p->size);

    /* flt: facility */
    for (i = 0; i < p->size; i++){
        lct = next_location(&set_lct);       
        flt = next_facility(p, &set_flt, lct);
        sol->perm[lct] = flt;
    }

    sol->cst = 0;
    for (i = 0; i < p->size; i++){
        for (j = i;  j < p->size; j++){
            sol->cst += p->dist[i][j] * p->flow[sol->perm[i]][sol->perm[j]];
            if (i != j){
                sol->cst += p->dist[j][i] * p->flow[sol->perm[j]][sol->perm[i]];
            }
        }
    }

    return sol;
}

void
set_test()
{
	printf("SET S: ");
	set* s = set_init();
	set_add(s, (SETDATA*)1);
	set_add(s, (SETDATA*)2);
	set_add(s, (SETDATA*)3);
	set_add(s, (SETDATA*)4);
	set_add(s, (SETDATA*)5);
	set_add(s, (SETDATA*)6);
	set_print(s, set_testcb);

	printf("S \\ 2, 6: ");
	set_remove(s, (SETDATA*)6);
	set_remove(s, (SETDATA*)2);
	set_print(s, set_testcb);
	
	printf("SET T: ");
	set* t = set_init();
	set_add(t, (SETDATA*)1);
	set_add(t, (SETDATA*)2);
	set_add(t, (SETDATA*)9);
	set_add(t, (SETDATA*)4);
	set_print(t, set_testcb);
	
	printf("UNION OF S, T: ");
	set* u = set_init();
	set_union(u, s, t);
	set_print(u, set_testcb);
	
	printf("INTERSECTION OF S, T: ");
	set* i = set_init();
	set_intersection(i, s, t);
	set_print(i, set_testcb);
	
	printf("DIFFERENCE OF S, T: ");
	set* d = set_init();
	set_difference(d, s, t);
	set_print(d, set_testcb);
	
	printf("CLEAR S: ");
	set_clear(s);
	set_print(s, set_testcb);
	
	set_free(s);
	set_free(t);
	set_free(u);
	set_free(i);
	set_free(d);
}

/* Does not detect loops, but they should not happen anyway */
int
grabContent(char *xml, char *url, struct crawlinfo *ci, set *acl_allow, set *acl_deny, char *usersid, CURL **curl, struct loginInfoFormat *login)
{
	acl_allow = malloc(sizeof(*acl_allow));
	acl_deny = malloc(sizeof(*acl_deny));
	set_init(acl_allow);
	set_init(acl_deny);
	getEmailUrls(xml, ci, url, acl_allow, acl_deny, usersid, curl, login);
	set_free_all(acl_allow);
	set_free_all(acl_deny);
	free(acl_allow);
	free(acl_deny);

	return 1;
}

int main()
{
	char op;
	while (scanf("%c", &op) != EOF)
	{
		if (op < 'a')
		{
			op += 'a' - 'A';
		}
		switch (op)
		{
			case 'd':
			{
				getlinenum();
				n = argv[1];
				set_init(n);
				/*if (n > 6000000)
				{
					for (;;);
				}*/
				break;
			}
			case 'c':
			{
				int i, st, ed;
				getlinenum();
				for (i = 1, st = argv[1], ed = argv[2]; (i <= argv[3])/* && (st <= n) && (ed <= n) && (st > 0) && (ed > 0) */; ++i, st += argv[5], ed += argv[4])
				{
					set_connect(st, ed);
				}
				break;
			}
			case 'q':
			{
				int i, st, ed;
				int s1 = 0;
				int s2 = 0;
				getlinenum();
				for (i = 1, st = argv[1], ed = argv[2]; (i <= argv[3])/* && (st <= n) && (ed <= n) && (st > 0) && (ed > 0) */; ++i, st += argv[5], ed += argv[4])
				{
					if (set_isconnect(st, ed))
					{
						++s1;
					}
					else
					{
						++s2;
					}
				}
				printf("%d - %d\n", s1, s2);
				break;
			}
			default:
			{
				break;
			}
		}
	}
	return 0;
}

int set_intersection(Set *seti, const Set *set1, const Set *set2)
{
        ListElmt *member;
        void *data;

        /*
         * Initialize set
         */
        set_init(seti, set1->match, NULL);

        /*
         * Insert elements that are in both sets
         */
        member = list_head(set1);
        for ( ; member != NULL; member = list_next(member)) {
                if (set_is_member(set2, list_data(member))) {
                        data = list_data(member);

                        if (list_ins_next(seti, list_tail(seti), data) != 0) {
                                set_destroy(seti);
                                return -1;
                        }
                }
        }

        return 0;
}

int set_difference(Set *setd, const Set *set1, const Set *set2)
{
        ListElmt *member;
        void *data;

        /*
         * Initialize set
         */
        set_init(setd, set1->match, NULL);

        /*
         * Insert elements that are in set1 but not set2
         */
        member = list_head(set1);
        for ( ; member != NULL; member = list_next(member)) {
                if (!set_is_member(set2, list_data(member))) {
                        data = list_data(member);

                        if (list_ins_next(setd, list_tail(setd), data) != 0) {
                                set_destroy(setd);
                                return -1;
                        }
                }
        }

        return 0;
}

/* add an entry to the map */
static void map_add(map_t *m, const char *key, const char *val)
{
    mapnode_t *tmp;
    unsigned int idx;

    if (!m) return;

    idx = hash_func(key) % m->nbuckets;
    tmp = m->buckets + idx;
    while (tmp->next != NULL) {
        if (strcmp(tmp->key,key) == 0) break;
        tmp = tmp->next;
    }

    /* add new entry to map */
    if (tmp->next == NULL) {
        m->count ++;
        tmp->key = my_strdup(key);
        tmp->val = set_init(50); /* XXX: chosen arbitrarily */
        tmp->next = (mapnode_t *)malloc(sizeof(mapnode_t));
        tmp->next->key = NULL;
        tmp->next->val = NULL;
        tmp->next->next = NULL;
    }
    set_add(tmp->val,val);
}

int set_union(Set *st, const Set *st1, const Set *st2){
	set_init(st, st1->destroy, st1->match);

	Node *pCurrentNode = list_head(st1);
	while(pCurrentNode){
		/* trust use's st1 is a really set(no duplicate node) */
		if(list_push(st, list_node_data(pCurrentNode)) != 0){
			set_destroy(st);
			return -1;
		}
		pCurrentNode = list_node_next(pCurrentNode);
	}

	pCurrentNode = list_head(st2);
	while(pCurrentNode){
		if(!set_is_member(st, list_node_data(pCurrentNode))){
			if(list_push(st, list_node_data(pCurrentNode)) != 0){
				set_destroy(st);
				return -1;
			}
		}
		pCurrentNode = list_node_next(pCurrentNode);
	}
	return 0;
}

int set_union(Set *setu, const Set *set1, const Set *set2) {
    ListElmt           *member;
    void               *data;
    set_init(setu, set1->match, NULL);
    for (member = list_head(set1); member != NULL; member = list_next(member)) {
        data = list_data(member);
        if (list_ins_next(setu, list_tail(setu), data) != 0) {
            set_destroy(setu);
            return -1;
        }
    }

    for (member = list_head(set2); member != NULL; member = list_next(member)) {
        if (set_is_member(set1, list_data(member))) {
            continue;
        }

        else {
            data = list_data(member);
            if (list_ins_next(setu, list_tail(setu), data) != 0) {
                set_destroy(setu);
                return -1;
            }
        }
    }

    return 0;
}

/* graph_ins_vertex */
int graph_ins_vertex(Graph *graph, const void *data)
{
	ListElmt *element;
	AdjList *adjlist;
	int retval;

	/* Do not allow the insertion of duplicate vertices. */
	for (element = list_head(&graph->adjlists); element != NULL; 
	     element = list_next(element)) {
		if (graph->match(data, 
			((AdjList *)list_data(element))->vertex)) {
			return 1;
		}
	}

	/* Insert the vertex. */
	if ((adjlist = (AdjList *)malloc(sizeof(AdjList))) == NULL) {
		return -1;
	}

	adjlist->vertex = (void *)data;
	set_init(&adjlist->adjacent, graph->match, NULL);

	if ((retval = list_ins_next(&graph->adjlists, 
		list_tail(&graph->adjlists), adjlist)) != 0) {
		return retval;
	}

	/* Adjust the vertex count to account for the inserted vertex. */
	graph->vcount++;
	return 0;
}

int
main(int argc, char ** argv)
{
    char * ifilename = "data/sigmafac/sigh.dat";
    int ifd = open(ifilename, 0666);
    void * buf = (void *) malloc(64);
    set * S, * matches;

    letter * p = WORDOF("*GAAT*");
    letter * _p = p;

    S = set_init(32);
    while (read_string(ifd, buf, 64, '\n'))
        if (*((char *) buf) != '\0')
            set_add_member(S, WORDOF((char *)buf));

    matches = pattern_shortest_matches(S, p, _p);

{
unsigned int i;
range_offset * r;
for (i=0; i<matches->members_count; i++)
{
r = (range_offset *)matches->members[i];
printf("%s %d %d\n", pattern_to_printable(r->_word), r->begin, r->end);
}    
}

    printf("%d\n", _find_cutoff_len(matches));
}

int graph_ins_vertex(Graph *graph, const void *data)
{
    ListElmt *element;
    AdjList *adjlist;
    int retval;

    // 不允许插入重复顶点
    for (element = list_head(&graph->adjlists); element != NULL; element = list_next(element)) {
        if (graph->match(data, ((AdjList *)list_data(element))->vertex)) {
            return 1;
        }
    }

    // 插入顶点
    if ((adjlist = (AdjList *)malloc(sizeof(AdjList))) == NULL) {
        return -1;
    }

    adjlist->vertex = (void *)data;
    set_init(&adjlist->adjacent, graph->match, NULL);

    if ((retval = list_ins_next(&graph->adjlists, list_tail(&graph->adjlists), adjlist)) != 0) {
        return retval;
    }

    graph->vcount++;
    return 0;
}

/* set_differece */
int set_differece(Set *setd, const Set *set1, const Set *set2)
{
    ListElmt *member;
    void *data;
    
    /* Initialize the set for the difference. */
    set_init(setd, set1->match, NULL);
    
    /* Insert the member from set1 not in set2. */
    for (member = list_head(set1); member != NULL; member = list_next(member))
    {
        if (!set_is_member(set2, list_data(member)))
        {
            data = list_data(member);
            
            if (list_ins_next(setd, list_tail(setd), data) != 0)
            {
                set_destroy(setd);
                return -1;
            }
        }
    }
    
    return 0;
}

/* set_t */
void _type_init_set(const void* cpv_input, void* pv_output)
{
    bool_t b_result = false;
    assert(cpv_input != NULL && pv_output != NULL);

    b_result = _create_set_auxiliary((set_t*)cpv_input, (char*)pv_output);
    assert(b_result);
    set_init((set_t*)cpv_input);
}