数据结构C语言版-栈

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>

using std::cout;

typedef int SElemType;
const int STACK_INIT_SIZE = 100;
const int STACKINCREMENT = 10;

typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;
} SqStack;

bool InitStack(SqStack &S);

bool DestoryStack(SqStack &S);

bool ClearStack(SqStack &S);

bool StackEmpty(SqStack S);

int StackLength(SqStack S);

bool GetTop(SqStack S, SElemType &e);

bool Push(SqStack &S, SElemType e);

bool Pop(SqStack &S, SElemType &e);

bool StackTraverse(SqStack S);

int main() {
    SqStack s;
    InitStack(s);
    Push(s, 5);
    Push(s, 6);
    Push(s, 7);
    Push(s, 8);
    int a;
    Pop(s, a);
    cout << a << std::endl;
    GetTop(s, a);
    cout << a << std::endl;

    if (StackEmpty(s)) {
        printf("is empty!\n");
    } else {
        printf("is not empty!\n");
    }
    SElemType b;
    printf("%d\n", StackLength(s));
    StackTraverse(s);
    while (!StackEmpty(s)) {
        int b;
        Pop(s, b);
        cout << b << std::endl;
    }
    ClearStack(s);
    DestoryStack(s);
}

bool StackTraverse(SqStack S) {
    if (S.top == S.base) {
        return false;
    }
    while (S.base < S.top) {
        printf("%d\t", *(S.base++));
    }
    printf("\n");
    return true;
}

bool DestoryStack(SqStack &S) {
    free(S.base);
    S.base = NULL;
    return true;
}

bool ClearStack(SqStack &S) {
    S.top = S.base;
    return true;
}

int StackLength(SqStack S) {
    if (S.base == S.top) {
        return 0;
    }
    return (int) (S.top - S.base);
}

bool StackEmpty(SqStack S) {
    if (S.top == S.base) {
        return true;
    }
    return false;
}

bool InitStack(SqStack &S) {
    S.base = (SElemType *) malloc(sizeof(SElemType) * STACK_INIT_SIZE);
    if (!S.base) {
        exit(OVERFLOW);
    }
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return true;
}

bool GetTop(SqStack S, SElemType &e) {
    if (S.top == S.base) {
        return false;
    }
    e = *(S.top - 1);
    return true;
}

bool Push(SqStack &S, SElemType e) {
    if (S.top - S.base >= S.stacksize) {
        S.base = (SElemType *) realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if (!S.base) {
            exit(OVERFLOW);
        }
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;
    return true;
}

bool Pop(SqStack &S, SElemType &e) {
    if (S.top == S.base) {
        return false;
    }
    e = *--S.top;
    return true;
}