stack_overflow（）函数如何工作？

Question

So I just came to the part in my book where stacks are explained. Here's how they get defined in my book (code):

#include <stdbool.h>

#define STACK_SIZE 100

int contents[STAC_SIZE]
int top = 0;

void make_empty(void){
    top = 0;
}

bool is_empty(void){
    return top == 0;
}

bool is_full(void){
    return top == STACK_SIZE;
}

void push(int i){
    if(is_full()){
        stack_overflow();
    }
    else{
        contents[top++] = I;
    }

int pop(void){
    if(is_empty()){
        stack_underflow();
    }
    else{
        return contents[--top];
    }
}

I don't get 2 things here:

• how can the make_empty() function work? By just initializing top to 0, contents has still all its elements loaded in... shouldn't contents be initialized as well?
• what do the 2 stack_overflow() and stack_underflow() functions do? Is their behavior defined by default in stdio.h ? If so, what happens when they get called? If not, am I supposed to define them by myself?

Also, just out of curiosity, is there a library that defines all the stack functions already?

Answer 1

To answer your questions in order:

1. make_empty() works like that because the push() function puts an element at the current top of the stack. Yes, contents still has the old values from the stack, however this is not important because they will be overwritten.

2. I think that stack_overflow() and stack_underflow() are put there just to illustrate what the normal behavior is when a push is made on a full stack, or a pop on an empty stack. They are not implemented in stdio.h. If you really want, you can create them yourself and include a printf, such as
   

    void stack_overflow() { printf("Stack Overflow! The program will crash!"); exit(1); //this function exits the program. It is defined in stdlib.h } 

Answer 2

The top variable tells the implementation where the top of the stack is, or, equivalently, how many elements it contains. That speaks to the logical contents, not the physical memory the stack occupies. Because this implementation uses an array to store the stack elements, every available position will always have some value stored in it. The key question is which correspond to bona fide stack elements , and that's exactly what top describes. Thus, make_empty() works by adjusting top to say that the stack storage contains no actual stack elements. The whole storage is available for elements.

The stack_overflow() and stack_underflow() are not standard functions. The names appear to be intended to convey the idea that a stack overflow or stack underflow occurs in that situation, without specifying any particular behavior.

A real-world implementation might implement those to emit a diagnostic message, return an error code (if the implementation provided for that, which the example doesn't), terminate, or, if it were a bit shoddy, commence undefined behavior in those cases. In the overflow case, there might also be the potential to expand the stack, but the details of your particular example do not make that a possibility.

Answer 3

how can the make_empty() function work?

Think about it this way: What effect do you expect make_empty to have? Well, to empty the stack obviously, but what does that mean in terms of the interface we have? A couple of things:

• After emptying the stack, is_empty should be true. Does setting top = 0 accomplish that? Yes, because is_empty just checks that top == 0 .
• After emptying the stack, popping it should cause an underflow. Does setting top = 0 accomplish that? Yes, because pop will cause an underflow if is_empty is true, which it will be.
• After emptying the stack, we should be able to push STACK_SIZE times before we get an overflow. Does setting top = 0 accomplish that? Yes, because push increases top by one each time and won't cause an overflow until top == STACK_SIZE . So if top is zero, we can push STACK_SIZE times.

By just initializing top to 0, contents has still all its elements loaded in... shouldn't contents be initialized as well?

To what? An array of size 0? We can't do that because contents has been declared to have size STACK_SIZE , not 0. An array's size is fixed and can never change.

We could set all of the elements to 0, but that wouldn't actually accomplish anything. The values of the elements with index >= top will never affect anything, so why bother changing them?

what do the 2 stack_overflow() and stack_underflow() functions do?

Presumably they're supposed to tell the user that an over- or underflow has occurred and then exit the application or invoke some sort of error handler.

Is their behavior defined by default in stdio.h?

No.

If not, am I supposed to define them by myself?

Presumably.