C堆栈实现会引发错误的访问错误

Question

在C中构建堆栈。在EXC_BAD_ACCESS函数的if检查中，堆栈偶尔会失败并出现isEmpty()错误，我不知道为什么。

Typedefs＆amp;定义：

#define NodeSize sizeof(StackNode)

struct stackNode {
    int data;
    struct stackNode *nextPtr;
};

typedef struct stackNode StackNode;
typedef StackNode *StackNodePtr;

堆栈操作函数

void push(StackNodePtr *topPtr, int value) {

    // Declare a new node and set it to the top
    StackNode *node;
    node = malloc(sizeof(NodeSize));

    node->data = value;
    node->nextPtr = *topPtr;

    // Reassign the pointer to the top
    *topPtr = node;

    printStack(*topPtr);
}

int pop(StackNodePtr *topPtr) {

    StackNode *node = *topPtr;

    if (isEmpty(node)) {
        return 0;
    }

    // Grab the current top node and reset the one beneath it to the top pointer.
    *topPtr = node->nextPtr;

    printStack(*topPtr);

    return node->data;
}

int isEmpty(StackNodePtr topPtr) {
    if (topPtr == NULL || topPtr->nextPtr == NULL) { // BAD_ACCESS
        return 1;
    }
    return 0;
}

void printStack(StackNodePtr topPtr) {

    StackNode *iter = topPtr;

    // If the stack is immediately empty, just print that.
    if (!isEmpty(iter->nextPtr)) {

        // Iterate over each element in the stack and print its data
        for (;isEmpty(iter); iter = iter->nextPtr) {
            printf("%d ", iter->data);
        }
        printf("NULL");
    } else {
        printf("NULL");
    }

    printf("\n");
}

void evaluatePostfixExpression(char *expr) {

    // Create the stack and insert an initial parenthesis
    StackNode *head;
    head = malloc(NodeSize);

    for (int i = 0; expr[i] != '\0'; i++) {
        char token = expr[i];

        // If the current character is a digit
        if (token >= '0' && token <= '9') {
            push(&head, token - '0');

        // If it's an operator
        } else if (token == '+' || token == '-' || token == '*' || token == '/' || token == '^' || token == '%') {

            int x = pop(&head);
            int y = pop(&head);

            int result = calculate(y, x, token);
            push(&head, result);
        }
    }

    int output = pop(&head);

    printf("The value of the expression is: %d\n", output);
}

int calculate(int op1, int op2, char operator) {
    switch (operator) {
        case '+':
            return op1 + op2;
        case '-':
            return op1 - op2;
        case '*':
            return op1 * op2;
        case '/':
            return op1 / op2;
        case '%':
            return op1 % op2;
    }

    if (operator == '^') {
        int result = 1;
        for (int i = 0; i < op2; i++) {
            result *= op1;
        }
        return result;
    }
    return 0;
}

即使只是正确方向的暗示也会受到赞赏。

请求上下文：

int main() {
    char postfix[255] = "54*81+4/+";

    evaluatePostfixExpression(postfix);

    return 0;
}

void evaluatePostfixExpression(char *expr) {

    // Create the stack and insert an initial parenthesis
    StackNode *head;
    head = malloc(NodeSize);

    for (int i = 0; expr[i] != '\0'; i++) {
        char token = expr[i];

        // If the current character is a digit
        if (token >= '0' && token <= '9') {
            push(&head, token - '0');

        // If it's an operator
        } else if (token == '+' || token == '-' || token == '*' || token == '/' || token == '^' || token == '%') {

            int x = pop(&head);
            int y = pop(&head);

            int result = calculate(y, x, token);
            push(&head, result);
        }
    }

    int output = pop(&head);

    printf("The value of the expression is: %d\n", output);
}

int calculate(int op1, int op2, char operator) {
    switch (operator) {
        case '+':
            return op1 + op2;
        case '-':
            return op1 - op2;
        case '*':
            return op1 * op2;
        case '/':
            return op1 / op2;
        case '%':
            return op1 % op2;
    }

    if (operator == '^') {
        int result = 1;
        for (int i = 0; i < op2; i++) {
            result *= op1;
        }
        return result;
    }
    return 0;
}

Answer 1

看起来像表达式

if (topPtr == NULL || topPtr->nextPtr == NULL)

给你一个错误，因为topPtr没有指向有效节点，也没有指向空。因此topPtr-＆gt; nextPtr会产生错误，因为topPtr不是有效的指针。

根据您的代码，您的head->nextPtr未初始化为NULL，因此这似乎是问题的原因。

顺便说一下：为什么用空节点初始化head变量？据我所见，您可以使用head = NULL，它可以正常工作。

最后但并非最不重要：您应该在node函数中释放pop()变量，以避免内存泄漏。

希望它有所帮助。