在C语言中构造堆栈数据结构的指针

Question

I've created a Stack structure in C. When the stack is initialized with a value, I am able to print it back and receive the correct output. However, after pushing a new string, the print function prints what appears to be a random character (ASCII 177).

Originally, I implemented this project with pointers, but I was unable to get it working. Instead, I opted to only use a pointer for the Node *nodes member of Stack . That way, when I need to grow the stack, I can just multiply the amount of memory required by Stack.size . However, this approach has not worked yet either.

#define MAX_DATA 64
struct Node{
    char val[MAX_DATA];
};

struct Stack{
    int size;
    struct Node *nodes;
};

These are used as follows:

struct Node node = {.val = "Test"};
struct Stack stack = newStack(node);
printStack(stack);

The newStack function initializes nodes properly. For the sake of inclusion:

struct Stack newStack(struct Node node)
{
    struct Stack stack;
    stack.size = 1;
    stack.nodes = (struct Node*) malloc(sizeof(struct Node));
    stack.nodes[0] = node;
    return stack;
}

The stack is then printed iteratively in printStack() , with stack.size being the upper bound of the for-loop.

The trouble comes when I try to run:

struct Node node2 = {.val = "Test1"};
push(stack, node2);
printStack(stack);

The push function aims to create a temporary stack and assign the value of the stack to it. After this, the size is incremented, the pointer to the nodes is freed, and new memory is allocated, with room for a new member at the end.

void push(struct Stack stack, struct Node node)
{
    struct Stack temp_stack = stack;
    stack.size += 1;
    free(stack.nodes);
    stack.nodes = (struct Node*) malloc(sizeof(struct Node) * stack.size);
    for(int i = 0; i < temp_stack.size; i++){
        stack.nodes[i] = temp_stack.nodes[i];
    }
    stack.nodes[stack.size - 1] = node;
}

Needless to say, this doesn't execute properly.

The expected output would be:

Test
Test1

But, instead, I receive only ASCII-177. It is also worth noting that the execution hangs after it prints that and moves to the new line. This results in Aborted (core dumped) .

Am I improperly freeing and re-allocating memory? Any help would be appreciated. Thank you in advance!

Answer 1

It's worth remembering that in C, passing a struct to a function is pass-by-value , ie, the function gets a copy of the struct. All members of the struct, including pointer variables (but not whatever the pointer references), are duplicated.

So in the push function, think about what happens to the original when you modify this copy (eg, stack.size += 1 , and also when you free() the stack.nodes.

Answer 2

Thank you to peekay for the recommendations. I ended up doing a re-write. It became quite a bit simpler. I did remove a layer of "visibility" by storing the nodes as a pointer, but I suppose this implementation is a bit more true to the data structure.

Node is implemented as a means to hold data, and the user doesn't interact with it directly. It also points to the following Node. Stack is implemented to hold the top Node, and also the size of the Stack.

Node:

struct Node{
    char val[MAX_DATA];
    struct Node *next;
};

Stack:

struct Stack{
    struct Node *top;
    int size;
};

Push:

void push(struct Stack *stack, char *newVal)
{
    struct Node *newNode;
    newNode = (struct Node*) malloc(sizeof(struct Node));
    strcpy(newNode->val, newVal);
    newNode->next = stack->top;
    stack->top = newNode;
    stack->size++;
}

Usage:

struct Stack stack;
newStack(&stack);

push(&stack, "Test");
push(&stack, "Test1");
push(&stack, "Test2");
push(&stack, "Test3");

Complete Code

Updated, accessible Nodes