C，全局变量更改不会保留在 function 之外

Question

In the pop() function i am trying to change the value of the Last global variable. It works fine in the push(n) function, while in the pop() one it changes it inside the function (verifying it with prints) but then it resets to the previous value just after leaving the method. Can't get my head around it.

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

int *Stack;
int Last = -1;

void make_empty( void ){
    free(Stack);
    Last = -1;
    Stack = NULL;
    //Stack = malloc(4);
    return;
}

int is_empty( void ){
    if (Last == -1)
        return 1;
    return 0;
}

int top( void ){
    if (is_empty()) {
        printf("La pila è vuota");
    }
    return Stack[Last];
}

int pop( void ){
    if (is_empty()) {
        printf("La pila è vuota");
        return 0;
    }
    int temp = Stack[Last];
    printf("last: %d\n", Last);
    Stack = realloc(Stack, (--Last+1)*sizeof(int));
    printf("last: %d\n", Last);
    return temp;
}

void push( int n ){
    Stack = realloc(Stack, (++Last+1)*sizeof(int));
    Stack[Last] = n;
    return;
}

void print_stack( void ){
    printf("last: %d\n", Last);
    for (int c=0; c<=Last; c++)
        printf("%d ", Stack[c]);
    printf("\n");
}

Answer 1

The implementation of the stack contains undefined behavior.

For example initially Last is equal to -1 .

int Last = -1;

then in the push operation

void push( int n ){
    Stack = realloc(Stack, ++Last*sizeof(int));
    Stack[Last] = n;
    return;
}

there is allocated memory of the size equal to 0 because ++Last is equal to 0 . You may not change the memory allocated with the size equal to 0 .

A similar problem exists for the method pop . When Last is equal to 0 then in this statement

Stack = realloc(Stack, --Last*sizeof(int));

the expression --Last is equal -1 that is converted to the maximum value of the type size_t due to the type of the operand sizeof(int) .

You could write for example the method push the following way

void push( int n ){
    Stack = realloc(Stack, ( ++Last + 1 ) *sizeof(int));
    Stack[Last] = n;
    return;
}

And in the pop method you could use

if ( Last == 0 ) 
{
    free( Stack );
    Stack = NULL;
}
else
{
    Stack = realloc(Stack, ( Last *sizeof(int));
}

--Last;

Pat attention to this if statement

if ( Last == 0 ) 
{
    free( Stack );
    Stack = NULL;
}

when the stack is empty all allocated memory must be freed and Stack must be set to NULL .

Answer 2

You're not allocating enough space for your stack.

At the start Last is -1. Then you push an element to the stack and allocate space:

Stack = realloc(Stack, ++Last*sizeof(int));

After the increment, Last is 0. So you're allocating 0*sizeof(int) == 0 bytes. You then write to Stack[Last] which doesn't exist. This invokes undefined behavior , which in your case manifests by causing a variable to change when you don't expect.

Since Last contains the last valid index, you want to add 1 to this to get the proper number of elements to allocate:

Stack = realloc(Stack, (++Last + 1)*sizeof(int));

You make a similar mistake when popping:

Stack = realloc(Stack, --Last*sizeof(int));

You also need to add 1 here:

Stack = realloc(Stack, (--Last + 1)*sizeof(int));