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

void test_stack_push(){    Stack *s = stack_new();    int a = 1;    int b = 2;    int c = 3;    stack_push(s, &a);    cc_assert(stack_peek(s) == &a,              cc_msg("stack_push: Top stack element not as expected"));    stack_push(s, &b);    cc_assert(stack_peek(s) == &b,              cc_msg("stack_push: Top stack element not as expected"));    stack_push(s, &c);    cc_assert(stack_peek(s) == &c,              cc_msg("stack_push: Top stack element not as expected"));    stack_destroy(s);}

void test_capacity_one_stack(){    Stack stk_instance = stack_new(1);    Stack *stk = &stk_instance;    StackResult result;    assert(stack_empty(stk));    assert(!stack_full(stk));    stack_peek(stk, &result);    assert(result.status == STACK_EMPTY);    stack_pop(stk, &result);    assert(result.status == STACK_EMPTY);    stack_push(stk, 99, &result);    assert(result.status == STACK_OK);    assert(stack_full(stk));    stack_push(stk, 222, &result);    assert(result.status == STACK_FULL);    stack_peek(stk, &result);    assert(result.data == 99 && result.status == STACK_OK);    stack_pop(stk, &result);    assert(result.data == 99 && result.status == STACK_OK);    assert(stack_empty(stk));}

int main(int argc, char const *argv[]){    int arr[] = {10, -15, 3, 2, 5, -2, 1, -1, -2, -3, -3, -10};    int len = sizeof(arr)/sizeof(int);    Stack s;    stack_init(&s, sizeof(int), compar_int);    for (int i = 0; i < len; ++i) {        printf("Pushing %d/n", arr[i]);        stack_push(&s, &arr[i]);        printf("Stack: ");        stack_int_print(&s);        printf("Stack mins: ");        list_int_print(s.mins);        if (!stack_empty(&s))            printf("stack_peek: %d/n",*(int *)stack_peek(&s));    }    while (!stack_empty(&s)) {        void *data = stack_pop(&s);        printf("Popped %d, freeing it./n", *(int *)data);        printf("Stack: ");        stack_int_print(&s);        printf("Stack mins: ");        list_int_print(s.mins);        if (!stack_empty(&s))            printf("stack_peek: %d/n", *(int *)stack_peek(&s));    }    return 0;}

static Nvhint_try_close(SaxDrive dr, const char *name) {    Hint	h = ox_hint_find(dr->hints, name);    Nv		nv;    if (0 == h) {	return 0;    }    for (nv = stack_peek(&dr->stack); 0 != nv; nv = stack_peek(&dr->stack)) {	if (0 == strcasecmp(name, nv->name)) {	    stack_pop(&dr->stack);	    return nv;	}	if (0 == nv->hint) {	    break;	}	if (nv->hint->empty) {	    end_element_cb(dr, nv->val, dr->buf.line, dr->buf.col);	    dr->stack.tail = nv;	} else {	    break;	}    }    return 0;}

int main() {    node* stack = new_stack();    int i;    for (i=0; i<10; i++) {       stack_push(stack, i);    }    assert(stack_peek(stack) == 9);    assert(stack_pop(stack) == 9);    assert(stack_peek(stack) == 8);}

static void pop_nested_expr(ExprQueue *pQueue, ExprStack *pStack){	ExprElement *pPeekElm = stack_peek(pStack);	for (;		pPeekElm != NULL && pPeekElm->type != OPEN_PAREN; 		pPeekElm = stack_peek(pStack))	{		queue_enqueue(pQueue, stack_pop(pStack));	}	stack_pop(pStack); //pop paren}

static void pop_lower_order_operations(ExprQueue *pQueue, ExprOperation *pOperation, 	ExprStack *pStack){	ExprElement *pPeekElm = stack_peek(pStack);	for (;		pPeekElm != NULL && pPeekElm->type == OPERATION			&& is_lower_precedence(pOperation, pPeekElm->value.pOpValue);		pPeekElm = stack_peek(pStack))	{		queue_enqueue(pQueue, stack_pop(pStack));	}}

static voidhash_set_value(ParseInfo pi, Val parent, VALUE value) {    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), value);    if (Yes == pi->options.trace) {	oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);    }}

static voidhash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {    Val	parent = stack_peek(&pi->stack);    if (0 != pi->options.create_id &&	*pi->options.create_id == *key &&	pi->options.create_id_len == klen &&	0 == strncmp(pi->options.create_id, key, klen)) {	if (str < pi->json || pi->cur < str) {	    parent->classname = oj_strndup(str, len);	} else {	    parent->classname = str;	}	parent->clen = len;    } else {	volatile VALUE	rstr = rb_str_new(str, len);	volatile VALUE	rkey = rb_str_new(key, klen);	rstr = oj_encode(rstr);	rkey = oj_encode(rkey);	if (Yes == pi->options.sym_key) {	    rkey = rb_str_intern(rkey);	}	rb_hash_aset(parent->val, rkey, rstr);    }}

void test_arbitrary_stack(){    Stack stk_instance = stack_new(0);    Stack *stk = &stk_instance;    StackResult result = { 0, RESULT_INVALID };    int i;    for (i = 0; i < MAX_DEPTH; i++) {        stack_push(stk, i, &result);        assert(result.status == STACK_OK);        result.status = RESULT_INVALID;    }    stack_push(stk, i, &result);    assert(result.status == STACK_FULL);    for (i = 0; i < MAX_DEPTH; i++) {        result.status = 0;        stack_peek(stk, &result);        assert(result.status == STACK_OK);        assert(result.data == MAX_DEPTH - i - 1);        result.status = RESULT_INVALID;        stack_pop(stk, &result);        assert(result.status == STACK_OK);    }    assert(stack_empty(stk));}

//pops an element from the stack//  const stack_t* stack - a pointer to the stack to use//  returns float - the float element that was previously at the top of//                  the stackfloat stack_peek_float(const stack_t* stack){  FloatInt_t fi;  fi.e = stack_peek(stack);  return fi.f;}

static voidhint_clear_empty(SaxDrive dr) {    Nv	nv;    for (nv = stack_peek(&dr->stack); 0 != nv; nv = stack_peek(&dr->stack)) {	if (0 == nv->hint) {	    break;	}	if (nv->hint->empty) {	    end_element_cb(dr, nv->val, dr->buf.line, dr->buf.col);	    stack_pop(&dr->stack);	} else {	    break;	}    }}

static voidarray_append_num(ParseInfo pi, NumInfo ni) {    if (ni->infinity || ni->nan) {	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");    }    rb_ary_push(stack_peek(&pi->stack)->val, oj_num_as_value(ni));}

struct media_entity *media_entity_graph_walk_next(struct media_entity_graph *graph){	if (stack_top(graph) == NULL)		return NULL;	while (link_top(graph) < stack_top(graph)->num_links) {		struct media_entity *entity = stack_top(graph);		struct media_link *link = &entity->links[link_top(graph)];		struct media_entity *next;				if (!(link->flags & MEDIA_LNK_FL_ENABLED)) {			link_top(graph)++;			continue;		}				next = media_entity_other(entity, link);				if (next == stack_peek(graph)) {			link_top(graph)++;			continue;		}				link_top(graph)++;		stack_push(graph, next);	}	return stack_pop(graph);}

void print_operand_stack(struct context *context){    null_check(context);    struct variable *operand;    for (int i=0; (operand = stack_peek(context->operand_stack, i)); i++)        DEBUGPRINT("/t%s/n", variable_value_str(context, operand));}

voidstart_fn(void *userData, const XML_Char *name, const XML_Char **atts){	struct stack *stk = (struct stack *) userData;	DOM_Node *parent, *child;	int i;	if (stk == NULL || name == NULL || atts == NULL) {		DOM_Exception = DOM_NULL_POINTER_ERR;		return;	}	parent = (DOM_Node *) stack_peek(stk);	if (parent == NULL) {		DOM_Exception = DOM_SYSTEM_ERR;		return;	}	child = DOM_Document_createElement(parent->ownerDocument, name);	if (child == NULL) {		return;	}	for (i = 0; atts[i]; i += 2) {		DOM_Element_setAttribute(child, atts[i], atts[i + 1]);		if (DOM_Exception) {			return;		}	}	if (DOM_Node_appendChild(parent, child) == NULL) {		return;	}	if (stack_push(stk, child) == 0) {		DOM_Exception = DOM_SYSTEM_ERR;	}}

static voidadd_value(ParseInfo pi, ojcVal val) {    ojcVal	parent = stack_peek(&pi->stack);    if (0 == parent) { // simple add	*pi->stack.head = val;    } else {	switch (parent->expect) {	case NEXT_ARRAY_NEW:	case NEXT_ARRAY_ELEMENT:	    ojc_array_append(&pi->err, parent, val);	    parent->expect = NEXT_ARRAY_COMMA;	    break;	case NEXT_OBJECT_VALUE:	    pi_object_nappend(pi, parent, val);	    if (pi->kalloc) {		free(pi->key);	    }	    pi->key = 0;	    pi->klen = 0;	    pi->kalloc = false;	    parent->expect = NEXT_OBJECT_COMMA;	    break;	case NEXT_OBJECT_NEW:	case NEXT_OBJECT_KEY:	case NEXT_OBJECT_COMMA:	case NEXT_NONE:	case NEXT_ARRAY_COMMA:	case NEXT_OBJECT_COLON:	default:	    ojc_set_error_at(pi, OJC_PARSE_ERR, __FILE__, __LINE__, "expected %s", _ojc_stack_next_str((ValNext)parent->expect));	    break;	}    }}

voidchardata_fn(void *userData, const XML_Char *s, int len){	struct stack *stk = (struct stack *) userData;	DOM_String *str;	DOM_Text *tex;	DOM_Node *parent;	if (stk == NULL || s == NULL || len == 0) {		DOM_Exception = DOM_NULL_POINTER_ERR;		return;	}	parent = (DOM_Node *) stack_peek(stk);	if (parent == NULL) {		DOM_Exception = DOM_SYSTEM_ERR;		return;	}	if ((str = (DOM_String *) malloc(len + 1)) == NULL) {		DOM_Exception = DOM_NO_MEMORY_ERR;		return;	}	memcpy(str, s, len);	str[len] = '/0';	tex = DOM_Document_createTextNode(parent->ownerDocument, str);	free(str);	if (tex == NULL) {		return;	}	DOM_Node_appendChild(parent, tex);	if (DOM_Exception) {		DOM_Document_destroyNode(parent->ownerDocument, tex);	}}

int print_paths(struct bitree_node *root){	struct bitree_node *node = root, *dummy;	struct bitree_node *last_visited = NULL, *peek;	struct stack_t parent_stack, *parent = &parent_stack;	struct stack_t path_stack, *paths = &path_stack;	int cnt = 0;	stack_init(parent, NULL);	stack_init(paths, NULL);	while (!stack_is_empty(parent) || node) {		if (node) {			stack_push(parent, (const void *) node);			stack_push(paths, (const void *) node);			node = node->left;		} else {			peek = (struct bitree_node *) stack_peek(parent);			if (peek->right && last_visited != peek->right) {				node = peek->right;			} else {				if (!peek->right && (peek->left != last_visited || !peek->left)) {					fprintf(stdout, "path %d:", ++cnt);					print_path_sum(paths);				}				stack_pop(parent, (void **) &last_visited);				stack_pop(paths, (void **) &dummy);			}		}	}	return cnt;}

void double_tree(struct bitree *tree){	struct bitree_node *node = tree->root;	struct bitree_node *last_visited = NULL, *peek;	struct stack_t parent_stack, *parent = &parent_stack;	if (tree == NULL)		return;	stack_init(parent, NULL);	while (!stack_is_empty(parent) || node) {		if (node) {			stack_push(parent, (const void *) node);			node = node->left;		} else {			peek = (struct bitree_node *) stack_peek(parent);			if (peek->right && last_visited != peek->right) {				node = peek->right;			} else {				double_tree_node(tree, peek);				stack_pop(parent, (void **) &last_visited);			}		}	}}

static void_st_bst_destroy(st_bst_node_t *root){  st_bst_node_t **pcur;  stack_t        *stack;  // hypothesis: all calls for the stack would not be failed  stack = stack_init(128, g_item_op->null);  (void) stack_push(stack, &g_dummy);  for (pcur = &root; *pcur != g_dummy; ) {    if ((*pcur)->left==g_dummy && (*pcur)->right==g_dummy) {      _st_bst_free_node(*pcur);      *pcur = g_dummy;      // "g_dummy->right == dummy" gives the terminate condition      pcur = stack_peek(stack);      if ((*pcur)->right == g_dummy) {        pcur = stack_pop(stack);      } else {        pcur = &(*pcur)->right;      }    } else {      stack_push(stack, pcur);      if ((*pcur)->left != g_dummy) {        pcur = &(*pcur)->left;      } else {        pcur = &(*pcur)->right;      }    }  }  stack_destroy(stack);}

static voidarray_append_value(ParseInfo pi, VALUE value) {    rb_ary_push(stack_peek(&pi->stack)->val, value);    if (Yes == pi->options.trace) {	oj_trace_parse_call("append_value", pi, __FILE__, __LINE__, value);    }}

static voidhash_set_num(struct _ParseInfo *pi, Val parent, NumInfo ni) {    if (ni->infinity || ni->nan) {	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");    }    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), oj_num_as_value(ni));}

static voidarray_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {    volatile VALUE	rstr = rb_str_new(str, len);    rstr = oj_encode(rstr);    rb_ary_push(stack_peek(&pi->stack)->val, rstr);}

static voidadd_num_value(ParseInfo pi, NumInfo ni) {    Val	parent = stack_peek(&pi->stack);    if (0 == parent) {	pi->add_num(pi, ni);    } else {	switch (parent->next) {	case NEXT_ARRAY_NEW:	case NEXT_ARRAY_ELEMENT:	    pi->array_append_num(pi, ni);	    parent->next = NEXT_ARRAY_COMMA;	    break;	case NEXT_HASH_VALUE:	    pi->hash_set_num(pi, parent, ni);	    if (parent->kalloc) {		xfree((char*)parent->key);	    }	    parent->key = 0;	    parent->kalloc = 0;	    parent->next = NEXT_HASH_COMMA;	    break;	default:	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s", oj_stack_next_string(parent->next));	    break;	}    }}

static voidhash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {    volatile VALUE	rstr = rb_str_new(str, len);    rstr = oj_encode(rstr);    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rstr);}

static voidadd_value(ParseInfo pi, VALUE rval) {    Val	parent = stack_peek(&pi->stack);    if (0 == parent) { // simple add	pi->add_value(pi, rval);    } else {	switch (parent->next) {	case NEXT_ARRAY_NEW:	case NEXT_ARRAY_ELEMENT:	    pi->array_append_value(pi, rval);	    parent->next = NEXT_ARRAY_COMMA;	    break;	case NEXT_HASH_VALUE:	    pi->hash_set_value(pi, parent, rval);	    if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {		xfree((char*)parent->key);		parent->key = 0;	    }	    parent->next = NEXT_HASH_COMMA;	    break;	case NEXT_HASH_NEW:	case NEXT_HASH_KEY:	case NEXT_HASH_COMMA:	case NEXT_NONE:	case NEXT_ARRAY_COMMA:	case NEXT_HASH_COLON:	default:	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "expected %s", oj_stack_next_string(parent->next));	    break;	}    }}

void post_order(node* n, void (*f)(int)) {  elt* stack;  stack = stack_init();  node *current, *temp;  current = n;  while (current != NULL || stack != NULL) {    if (current != NULL) {      if (current->right != NULL) {        stack_push(&stack, current->right);      }      stack_push(&stack, current);      current = current->left;    } else {      current = stack_pop(&stack);      if (current->right != NULL && stack != NULL &&          stack_peek(stack)->value == current->right->value) {        temp = current;        current = stack_pop(&stack);        stack_push(&stack, temp);      } else {        (*f)(current->value);        current = NULL;      }    }  }}

int main() {  int elt; // element to be pushed and poped  char c;  // 'switch(c)' of the main loop    // display management  const char *prompt = "> ";  int prompt_count = 1;    print_usage();  printf("%i%s", prompt_count++, prompt);      /*---------------------------  Main loop of the test program  ---------------------------*/  while ( (c = getchar()) != 'Q')  {    switch(c)    {      case 'p':  // put        if (scanf("%i", &elt) != 1) goto error_scanf;             stack_put(elt);        printf("%i/n", elt);        break;              case 'g':  // get        elt = stack_get();        printf("%i/n", elt);        break;      case 'r': // retrieve, cannot use p for peek :-(        elt = stack_peek();          printf("%i/n", elt);        break;                      default:        print_usage();        break;    }    while (getchar() != '/n') {} /* skip end of line */    printf("%i%s", prompt_count++, prompt);    continue;  // all is ok, go to the beginning of the main loop    /*----- ERROR TREATMENT -----*/ error_scanf:    while (getchar() != '/n') {} /* skip end of line */    printf("ERROR: wrong scanf argument/n");    printf("%i%s", prompt_count++, prompt);    continue;/*----- END ERROR TREATMENT -----*/       }  /*--------------------------------------  End of the main loop of the test program  --------------------------------------*/  printf("Quit/n");  return 0;}

void *peek (stack_t stack_in, stack_t stack_out){  /* Balance the outstack */  balance (stack_in, stack_out);  return stack_peek (stack_out);}