C++ (Cpp) swap_pointer Examples

Example #1

File: section_5.6_pointer_array.c Project: syuxue/Learning-C

void qsort(void *lineptr[], int left, int right,
	int (*comp)(void *, void *), 
	int op_reverse, int op_key)
{
	int i,base;

	if (left >= right) return;

	base = left;
	for (i = left + 1; i <= right; i++) {
		if (compare(lineptr[i], lineptr[base], comp) * op_reverse < 0) {
		//if ((*comp)(lineptr[i], lineptr[base]) * op_reverse < 0) {
			swap_pointer(lineptr, i, ++left);
		}
	}
	swap_pointer(lineptr, base, left);

	qsort(lineptr, base, left, comp, op_reverse, op_key);
	qsort(lineptr, left + 1, right, comp, op_reverse, op_key);
}

Example #2

File: 7.swap.c Project: Rston/GccC

int main(int argc, char **argv)
{
	int x =3, y = 5;
	
	printf("bfore swap: x = %d. y = %d.\n", x, y);
	swap(x, y);
	printf("after swap: x = %d. y = %d.\n", x, y);
	
	printf("bfore swap_pointer: x = %d. y = %d.\n", x, y);
	swap_pointer(&x, &y);
	printf("after swap_pointer: x = %d. y = %d.\n", x, y);
	
	return 0;
}

Example #3

File: nfa_closure.c Project: Incarnation-p-lee/scil

static inline void
nfa_closure_char_seek(s_fa_closure_t *closure, char c)
{
    s_fa_status_t *status;

    assert_exit(c != NULL_CHAR);
    assert_exit(nfa_closure_structure_legal_p(closure));

    closure->c = c;
    swap_pointer((void *)&closure->path_queue, (void *)&closure->collection);

    while (!array_queue_empty_p(closure->path_queue)) {
        status = array_queue_leave(closure->path_queue);
        nfa_closure_char_status_seek(closure, status, c);
    }
}

Example #4

File: splay_tree.c Project: Incarnation-p-lee/libds

static inline sint32
splay_tree_height_i(s_splay_tree_t *tree)
{
    sint32 height;
    s_splay_tree_t *splay_node;
    s_array_queue_t *queue_master, *queue_slave;

    if (!tree) {
        return -1;
    } else {
        height = -1;
        splay_node = tree;

        queue_slave = array_queue_create();
        queue_master = array_queue_create();
        array_queue_enter(queue_master, splay_node);

        while (!array_queue_empty_p(queue_master)) {
            splay_node = array_queue_leave(queue_master);

            if (splay_node->left) {
                array_queue_enter(queue_slave, splay_node->left);
            }

            if (splay_node->right) {
                array_queue_enter(queue_slave, splay_node->right);
            }

            if (array_queue_empty_p(queue_master)) {
                height++;
                swap_pointer((void **)&queue_master, (void **)&queue_slave);
            }
        }

        array_queue_destroy(&queue_master);
        array_queue_destroy(&queue_slave);

        return height;
    }
}

Example #5

File: bptree.c Project: braydencn/b_plus_tree_complete

/* Delete one entry from leaf node or index node; 
 * make ajustment to maintain bptree
 */
void
bpt_delete_entry(bpt_node** root, bpt_node* n, void* v)
{
	/* Only delete from node, no ajust yet. */
	bpt_delete_in_node(n, v);

	if(bpt_is_root(n)){
	       if(! bpt_is_enough(n) && !bpt_is_leaf(n)) 
			/* So root is not leaf node and only has one child */
			bpt_replace_root_with_child(root);
	}else if(! bpt_is_enough(n)){
	        /* Not enough record in the node now, so need ajustment. */	
		long k;
		bpt_node* n1;

		bpt_get_close_sibling(n, &n1, &k);

		if((n->num_of_rec + n1->num_of_rec) <= BPT_MAX_REC_NO){
			/* merge node and its close sibling */
			if(n->key[0] > n1->key[0])
				swap_pointer((void**)&n, (void**)&n1);

			if(bpt_is_leaf(n))
				bpt_merge_leaf(root, n, &n1);
			else bpt_merge_index(root, n, k, &n1);
		}else{
			/* borrow one entry from its close sibling */
			if(n->key[0] > n1->key[0]){
				if(bpt_is_leaf(n))
					bpt_borrow_from_pre_leaf(n,n1);
				else bpt_borrow_from_pre_index(n, k, n1);
			}else{
				if(bpt_is_leaf(n))
					bpt_borrow_from_post_leaf(n, n1);
				else bpt_borrow_from_post_index(n, k, n1);
			}
		}
	}
}