顺序栈

#include<malloc.h>
#include<stdio.h>


/**<------------------------顺序栈-----------------------------------*/
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define SIZE 10
#define INCREAMENT 10
typedef struct Stack
{
    int stack_size;
    int *top, *base;

}Stack;

/**<
运算符->是运算符*和运算符.的结合
->与*.是否等价的问题，理论上确实是等价的,比如这里的isEmpty与Destroy函数Stack s后.与->就等价,
但在实践中有所区别，特别是在调core中。以空指针和野指针为例。->都会直接导致出core
.前面是结构体，->前面是结构体指针
*/




int InitStack(Stack *s);
int isEmpty(Stack *s);
int push(Stack *s, int e);
int pop(Stack *s, int *e);
void Destroy(Stack *s);


int main()
{
    Stack s;
    int e;
    int i;
    InitStack(&s);
    printf("请输入：\n");
    for(i=0; i<3; ++i)
    {
        scanf("%d", &e);
        push(&s, e);
    }
    printf("栈顶元素为：%d\n", GetTop(&s));
    for(i=0; i<3; ++i)
    {
        pop(&s, &e);
        printf("%d ", e);
    }
    if(isEmpty(&s))     printf("\n栈为空\n");
    Destroy(&s);
    return 0;
}


int InitStack(Stack *s)
{
    s->base= (int*)malloc(SIZE * sizeof(int));
    if(!s->base)     exit(OVERFLOW);
    s->top = s->base;
    s->stack_size = SIZE;
    return OK;
}


int push( Stack *s, int e)
{
    if(s->top - s->base >= s->stack_size)
    {
        s->base = (int*)realloc(s->base, (SIZE+INCREAMENT)*sizeof(int));
        s->top = s->base + s->stack_size;
        s->stack_size = SIZE+INCREAMENT;
    }
    *s->top = e;
    ++s->top;
    return OK;
}


int pop(Stack *s, int *e)
{
    if (s->base == s->top)
        return ERROR;
    *e = *--s->top;
    return OK;
}
int GetTop(Stack *s)                        /**<获取栈顶元素*/
{
    return *(s->top-1);
}


int isEmpty( Stack *s)
{
    return (s->top && s->base);             /**<栈顶等于栈底时栈为空，返回1*/
}


void Destroy(Stack *s)
{
    free(s->base);
    s->base = s->top =NULL;                 /**<必有的一步，否则会成为野指针*/
    s->stack_size = 0;
}