C 用动态数组实现堆栈

我已经使用动态数组实现了一个堆栈（实现数组加倍），但是当第二次加倍时，我得到了运行时错误！实施出了什么问题？请帮忙

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

struct Stack {
    int *arr;
    int top,size,capacity;
};

struct Stack *createStack(int capacity) {
    struct Stack *s = (struct Stack*)malloc(sizeof(struct Stack));
    s->arr = (int*)malloc(sizeof(int)*capacity);
    s->top = -1;
    s->capacity = capacity;
    s->size = 0;
    return s;
}

void doubleStack(struct Stack *s) {
    s->capacity = s->capacity*2;
    s->arr = realloc(s->arr,s->capacity);
    printf("Array doubling happened successfully!\n");
}

int isFull(struct Stack *s) {
    return s->size == s->capacity;
}

void push(struct Stack *s, int item) {
    if(isFull(s))
        doubleStack(s);

    printf("%d pushed!\n",item);
    s->arr[++(s->top)] = item;
    s->size++;
}

int isEmpty(struct Stack *s) {
    return s->size == 0;
}

void pop(struct Stack *s) {
    if(isEmpty(s)) {
        printf("Empty stack!\n");
        return;
    }

    int item = s->arr[(s->top)--];
    s->size--;
    printf("%d popped!\n",item);
}

int main(void) {
    struct Stack *s = createStack(2);
    push(s,1);
    push(s,2);
    push(s,3);
    push(s,4);
    push(s,5);
    pop(s);
    pop(s);
    return 0;
}

#包括
#包括
结构堆栈{
int*arr；
int顶部、尺寸、容量；
};
结构堆栈*createStack（整数容量）{
结构堆栈*s=（结构堆栈*）malloc（sizeof（结构堆栈））；
s->arr=（int*）malloc（sizeof（int）*容量）；
s->top=-1；
s->容量=容量；
s->size=0；
返回s；
}
无效双堆栈（结构堆栈*s）{
s->capacity=s->capacity*2；
s->arr=realloc（s->arr，s->容量）；
printf（“阵列加倍成功！\n”）；
}
int isFull（结构堆栈*s）{
返回s->size==s->capacity；
}
无效推送（结构堆栈*s，int项）{
如果（已满）
双栈；
printf（“%d推式！\n”，项）；
s->arr[++（s->top）]=物料；
s->size++；
}
int isEmpty（结构堆栈*s）{
返回s->size==0；
}
void pop（结构堆栈*s）{
如果（i）是空的{
printf（“空堆栈！\n”）；
返回；
}
int item=s->arr[（s->top）--]；
s->尺寸--；
printf（“%d弹出！\n”，项）；
}
内部主（空）{
struct Stack*s=createStack（2）；
推（s，1）；
推（s，2）；
推（s，3）；
推（s，4）；
推（s，5）；
流行音乐(s);；
流行音乐(s);；
返回0；
}

您未能将通过

realloc（）

分配的大小乘以

sizeof（int）

试着做一些其他的改进：

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

struct Stack {
    int *arr;
    int top,size,capacity;
};

struct Stack *createStack(int capacity) {
    struct Stack *s = malloc(sizeof(struct Stack));
    s->arr = malloc(sizeof(int)*capacity);
    s->top = -1;
    s->capacity = capacity;
    s->size = 0;
    return s;
}

void destroyStack(struct Stack *s) {
    if(s != NULL) free(s->arr);
    free(s);
}

void doubleStack(struct Stack *s) {
    s->capacity = s->capacity*2;
    s->arr = realloc(s->arr,sizeof(int)*s->capacity);
    if(s->arr != NULL) {
        printf("Array doubling happened successfully!\n");
    } else {
        perror("realloc");
    }
}

int isFull(struct Stack *s) {
    return s->size == s->capacity;
}

void push(struct Stack *s, int item) {
    if(isFull(s))
        doubleStack(s);

    printf("%d pushed!\n",item);
    s->arr[++(s->top)] = item;
    s->size++;
}

int isEmpty(struct Stack *s) {
    return s->size == 0;
}

void pop(struct Stack *s) {
    if(isEmpty(s)) {
        printf("Empty stack!\n");
        return;
    }

    int item = s->arr[(s->top)--];
    s->size--;
    printf("%d popped!\n",item);
}

int main(void) {
    struct Stack *s = createStack(2);
    push(s,1);
    push(s,2);
    push(s,3);
    push(s,4);
    push(s,5);
    pop(s);
    pop(s);
    destroyStack(s);
    return 0;
}

#包括
#包括
结构堆栈{
int*arr；
int顶部、尺寸、容量；
};
结构堆栈*createStack（整数容量）{
结构堆栈*s=malloc（sizeof（结构堆栈））；
s->arr=malloc（sizeof（int）*容量）；
s->top=-1；
s->容量=容量；
s->size=0；
返回s；
}
void destroyStack（结构堆栈*s）{
如果（s！=NULL）空闲（s->arr）；
免费的；
}
无效双堆栈（结构堆栈*s）{
s->capacity=s->capacity*2；
s->arr=realloc（s->arr，sizeof（int）*s->capacity）；
如果（s->arr！=NULL）{
printf（“阵列加倍成功！\n”）；
}否则{
perror（“realloc”）；
}
}
int isFull（结构堆栈*s）{
返回s->size==s->capacity；
}
无效推送（结构堆栈*s，int项）{
如果（已满）
双栈；
printf（“%d推式！\n”，项）；
s->arr[++（s->top）]=物料；
s->size++；
}
int isEmpty（结构堆栈*s）{
返回s->size==0；
}
void pop（结构堆栈*s）{
如果（i）是空的{
printf（“空堆栈！\n”）；
返回；
}
int item=s->arr[（s->top）--]；
s->尺寸--；
printf（“%d弹出！\n”，项）；
}
内部主（空）{
struct Stack*s=createStack（2）；
推（s，1）；
推（s，2）；
推（s，3）；
推（s，4）；
推（s，5）；
流行音乐(s);；
流行音乐(s);；
销毁堆栈；
返回0；
}

注意：他们说。

printf（“阵列加倍成功发生！\n”）而不检查
realloc（）
是否成功？胡说八道。这不是为了检查内存分配是否成功，而是为了告诉您阵列倍增的次数！我很感激你的帮助，但请注意行话！感谢您的快速回复，它的工作。我有一个问题，为什么它会在第二次错误加倍时产生错误，而不是在第一次错误加倍时产生错误？