c 中的基本内存分配和释放

Question

Hi I'm new to C programming and have some dificulties with memory allocation

trying to implment a stack using an array

my SP_Stack.c:

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

struct sp_stack_struct {
      SP_STACK_ELEMENT *elements;
      int top;
};

SP_STACK* spStackCreate(){

    SP_STACK *new_stack = (SP_STACK*)malloc(sizeof(SP_STACK));
    SP_STACK_ELEMENT *newContents = (SP_STACK_ELEMENT*)malloc(sizeof(SP_STACK_ELEMENT)*1024);

    /* make sure to return NULL if needed */
    if( newContents == NULL){
        return NULL;
    }
    new_stack->elements = newContents;
    new_stack->top = -1;
    return new_stack;
}

void spStackDestroy(SP_STACK* stack){
    //while(!spStackIsEmpty(stack,NULL)){
        //spStackPop(stack,NULL);
//  }
    free(stack->elements);
    free(stack);
}

SP_STACK_ELEMENT* spStackTop (SP_STACK* stack){
    // make sure to return NULL
    if (stack == NULL || spStackIsEmpty(stack)){
        return NULL;
    }
    return &(stack->elements[(stack->top)]);
}
SP_STACK* spStackPop(SP_STACK* stack){

    if (!(stack == NULL || spStackIsEmpty(stack))){
        //free(&(stack->elements[stack->top]));
        //stack->top--;
    }
    return stack;
}
SP_STACK* spStackPush(SP_STACK* stack, SP_STACK_ELEMENT newElement){
    if (stack == NULL){
        return NULL;
    }
    // copy element so he will stay in memory
    SP_STACK_ELEMENT* copyElement = (SP_STACK_ELEMENT*)malloc(sizeof(SP_STACK_ELEMENT));
    copyElement->type = newElement.type ;
    copyElement->value = newElement.value;

    stack->elements[++stack->top] = *copyElement;
    return stack;
}
bool spStackIsEmpty(SP_STACK* stack){

    return stack->top < 0;
}

my SP_Stack.h

typedef enum {
    PLUS,
    MINUS,
    MULTIPLICATION,
    DIVISION,
    DOLLAR,
    NUMBER,
    UNKNOWN
} SP_STACK_ELEMENT_TYPE;

typedef struct {
    SP_STACK_ELEMENT_TYPE type;
    double value;
} SP_STACK_ELEMENT;

typedef struct sp_stack_struct SP_STACK;
SP_STACK* spStackCreate();
void spStackDestroy(SP_STACK* stack);
SP_STACK_ELEMENT* spStackTop (SP_STACK* stack);
SP_STACK* spStackPop(SP_STACK* stack);
SP_STACK* spStackPush(SP_STACK* stack, SP_STACK_ELEMENT newElement);
bool spStackIsEmpty(SP_STACK* stack);

#endif /* SP_STACK_H_ */

my tester:

#include "SP_Stack.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>

int main(){
    SP_STACK_ELEMENT* elementPtr = NULL;
    SP_STACK * stack = spStackCreate();
    elementPtr = spStackTop(stack);

    SP_STACK_ELEMENT newElement = {.type = NUMBER , .value = 100};
    SP_STACK_ELEMENT newElement2 = {.type = NUMBER , .value = 200};
    SP_STACK_ELEMENT newElement3 = {.type = NUMBER , .value = 300};
    SP_STACK_ELEMENT newElement4 = {.type = NUMBER , .value = 400};
    SP_STACK_ELEMENT newElement5 = {.type = NUMBER , .value = 500};

    stack = spStackPush(stack,newElement);
    stack = spStackPush(stack,newElement2);
    stack = spStackPush(stack,newElement3);
    stack = spStackPop(stack);

    spStackDestroy(stack);
    return 1;
}

my problem is - every time I try to pop an element, my program crashes.

I tried to check my stack->top value is correct an it is. I also verified it contains an object by printing the object value in location stack->top

I tried to delete a specific index in my array:

free(&(stack->elements[0]));

works but, any other index:

free(&(stack->elements[1]));

crashes, even if elments[i] exits.

what am I doing wrong? thx

Answer 1

You have a misconception about how your data is organised in the stack.

You have a dynamic array of entries. This array is created with malloc and represented by a pointer, namely the handle to the heap memory.

After you have initialised your stack, that array already contains 1024 uninitialised elements. When you push values, you copy the contents of the array to the top slot. Your code looks like this:

SP_STACK_ELEMENT *copyElement =
    (SP_STACK_ELEMENT *) malloc(sizeof(SP_STACK_ELEMENT));

copyElement->type = newElement.type;
copyElement->value = newElement.value;
stack->elements[++stack->top] = *copyElement;

You allocate memory, copy the parameters to the copy and then copy the contents of the copy to the array element. The intermediate copy is useless. Worse, the allocated memory is lost, because the handle to copyElement immediately.

The code should be just:

stack->elements[++stack->top] = *newElement; 

Conversely, because the memory for the pushed element wasn't really malloc ed, you can't free it. But because you can't return a pointer to memory that might be overwritten immediately, you can't return the popped element as pointer.

Now you have to make a decision: What do you want to store? Elements or pointers to elements. Storing elements is feasible and easy if your elements are lightweight, for example if they are ints, or doubles. Your struct is lightweight and can be passed around by value. On the other hand, if you store pointers, your client code – the code that uses the stack – must manage the memory.

There are other issues with your code:

• You allocate the stack data proper to a local variable when you initialise the stack, but you never assign it to stack->elements .

• Instead of freeing the individual elements, you should free the memory that you have allocated on initialisation. This is best done by a "destructor" or clean-up function.

• Having the top index refer to the top element is not C-like and means that you have the index −1 when the stack is empty. I would prefer to make the top member a count, so that en empty stack is represented by a count of zero. That makes checking against over- and underflow easier. It also means that you can use the (unsigned) size_t type as index, which is a good choice.

Below is an example that implements a stack as you may have intended it. It stores the elements and passes them around as values. See how, except for the over- and underflow checks, the push and pop functions are very simple.

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

enum Type {
    PLUS,
    MINUS,
    NUMBER,
    UNKNOWN
};

typedef struct Stack Stack;
typedef struct Element Element;

struct Element {
    enum Type type;
    double value;
};

struct Stack {
    size_t count;
    Element *elem;
};

#define SP_SIZE 1024

Stack *spStackCreate(void)
{
    Stack *stack = malloc(sizeof(*stack));
    Element *elem = malloc(SP_SIZE * sizeof(*elem));

    if (stack == NULL || elem == NULL) {
        free(stack);
        free(elem);
        return NULL;
    }

    stack->elem = elem;
    stack->count = 0;

    return stack;
}

void spStackDestroy(Stack *stack)
{
    if (stack) {
        free(stack->elem);
        free(stack);
    }
}

void spStackPush(Stack *stack, Element elem)
{
    if (stack->count >= SP_SIZE) {
        fprintf(stderr, "Stack overflow!\n");
        exit(1);
    }

    stack->elem[stack->count++] = elem;
}

Element spStackPop(Stack *stack)
{
    if (stack->count == 0) {
        fprintf(stderr, "Stack underflow!\n");
        exit(1);
    }

    return stack->elem[--stack->count];
}

int spStackIsEmpty(const Stack *stack)
{
    return (stack->count == 0);
}



int main()
{
    Stack *stack = spStackCreate();
    int i, j = 1;

    if (stack == NULL) exit(1);

    for (i = 0; i < 10; i++) {
        Element elem = {NUMBER, j};

        spStackPush(stack, elem);
        j += i;
    }

    while (!spStackIsEmpty(stack)) {
        Element elem = spStackPop(stack);

        printf("%g\n", elem.value);
    }

    spStackDestroy(stack);
    return 0;
}

Answer 2

my problem is - every time I try to pop an element, my program crashes.

I tried to check my stack->top value is correct an it is. I also verified it contains an object by printing the object value in location stack->top

I tried to delete a specific index in my array:

free(&(stack->elements[0])); works but, any other index:

free(&(stack->elements[1])); crashes, even if elments[i] exits.

The first one is working because the & operator is taking the address of the first cell in your stack->elements array (that address matches the address returned by the malloc() call (the one when you initialize the newContents variable and so it is a legit address to free() .

The second one is getting the address of the second cell in your array, this pointer was not obtained from a malloc() call, and as such is very likely to crash when you attempt to free() it.

Try removing the & operator from free(&(stack->elements[1])) , you want to free the actual element, not the cell containing the pointer to the element.