Question

so I’m having a crazy time right now reading characters off a stack. I’m storing the char as an int, so I can check for the EOF signal, but things aren’t going so well. I’m new to the implementation of stacks, so things are probably just wrong somewhere. Here’s my code.

I’m getting both the incorrect top character on the stack (it shows -1, which is EOF, instead of the last character entered), as well as some sort of memory error – “pointer being freed was not allocated”, which references the destroyStack() function.

int main( void ) {
    int *letter;
    STACK   *stack;

    stack = createStack();

    letter = (int *) malloc( sizeof( int ) );

    printf("Please enter the letters, each on a new line, or  to quit:\n");

    while ( *letter != EOF || stackFull( stack ) ) {
        *letter = getchar();

        if ( *letter != '\n' && *letter != ' ' && *letter != EOF ) {
            printf("Adding %c to the stack.\n", *letter);
            pushStack( stack, letter );
        }
    }

    free( letter );

    printf("Stack count is %i\n", stackCount(stack));

    letter = (int *) getStackTop( stack );

    printf("The top char is %i\n",  *letter);

    destroyStack( stack );

    return 0;
}

and my stack code:

typedef struct node {
    void            *dataPointer;
    struct node     *link;
} NODE;

typedef struct {
    int     count;
    NODE    *top;
} STACK;

STACK* createStack() {
    STACK   *stack;

    stack = (STACK *) malloc( sizeof( STACK ) );

    if ( stack ) {
        stack->count    = 0;
        stack->top      = NULL;
    }

    return stack;
}

bool pushStack( STACK *stack, void  *pointerToData) {
    NODE    *newNode;

    newNode = (NODE *) malloc( sizeof( NODE ) );

    if ( !newNode ) {
        return false;
    }

    newNode->dataPointer    = pointerToData;
    newNode->link           = stack->top;
    stack->top              = newNode;

    ( stack->count )++;

    return true;
}

void* popStack( STACK *stack ) {
    void*   topData;
    NODE*   temp;

    if ( stack->count == 0 ) {
        topData = NULL; 
    } else {
        temp        = stack->top;
        topData     = stack->top->dataPointer;
        stack->top  = stack->top->link;

        free( temp );

        ( stack->count )--;
    }

    return topData;
}

void* getStackTop( STACK *stack ) {
    if ( stack->count == 0 ) {
        return NULL;
    } else {
        return stack->top->dataPointer;
    }
}

bool stackEmpty( STACK *stack ) {
    return ( stack->count == 0 );   
}

bool stackFull( STACK *stack ) {
    NODE    *temp;

    if ( ( temp = (NODE *) malloc( sizeof( *(stack->top) ) ) ) ) {
        free( temp );

        return false;
    }

    return true;
}

int stackCount( STACK *stack ) {
    return ( stack->count );
}

STACK* destroyStack( STACK *stack ) {
    NODE    *temp;

    if ( stack ) {
        while ( stack->top != NULL ) {
            free( stack->top->dataPointer );

            temp = stack->top;          
            stack->top = stack->top->link;

            free( temp );
        }

        free( stack );
    }

    return NULL;
}

Answer 1

Your problem is with letter. It’s only allocated once and when you push it onto the stack, it doesn’t make a copy. That’s why your top data pointer is always the last thing you pushed. Then you free it and destroyStack frees it and you get another error. Since the stack functions were from your assignment, the fix is to allocate a new data pointer inside the loop every iteration and ensure that it’s not freed outside of destroyStack.