Difference between using char [] and malloc-ed char* in this code

[crystalize123]

Hello folks! I am currently practicing my C skills by coding a calculator that takes infix input and turns it into postfix format then uses stack to calculate the expression.

This is the transition function that takes in infix format and outputs postfix format.

int getPriority(char* symbol){
    if(!strcmp(symbol, "(")) return 0;
    if(!strcmp(symbol, "+") || !strcmp(symbol, "-")) return 1;
    if(!strcmp(symbol, "*") || !strcmp(symbol, "/")) return 2;
    return 3;
}


char* transition(Stack *stack, char* input){

//    char* postfix = (char*)malloc(sizeof(char)*10000);
//    memset(postfix, 0x00, 10000);
    char postfix[10000] = "";
    char* token = strtok(input, " ");
    while(token != NULL){
        if(!strcmp(token, "(")){
            push(stack, token);
        }
        else if(!strcmp(token, ")")){
            while(strcmp(getTop(stack), "(")){

                strcat(postfix, pop(stack));
                strcat(postfix, " ");
            }

            pop(stack);
        }
        else if(!strcmp(token, "+") || !strcmp(token, "-") || !strcmp(token, "*") || !strcmp(token, "/")){

            while(stack->top != NULL && getPriority(getTop(stack)) >= getPriority(token)){

                strcat(postfix, pop(stack));
                strcat(postfix, " ");
            }
            push(stack, token);
        }
        else{

            strcat(postfix, token);
            strcat(postfix, " ");
        }
        token = strtok(NULL, " ");

    }
    while(stack->top != NULL ){

        strcat(postfix, pop(stack));
        strcat(postfix, " ");
    }
    return postfix;
}

This function returns postfix character array, which is currently implemented in the function as

char postfix[10000] = "";

I've tried the malloc method which is right above the above code, and works equally fine.

What is the difference between these two implementations? I am suspecting that it has to do something with the memory layout of the program, since malloc will definitely create space for postfix pointer in the heap.

But I am not sure where the character array postfix will leave its mark in the memory layout. If it is stored in the stack, then I am not sure why it won't return memory error during runtime since the stack memory is freed after its return in the main function.

Thanks for helping out.

[Salem]

You're right.
As written (with an array), the string in postfix will be lost when the function returns.

You either need to use malloc (in which case you need to free the returned pointer),
or make the array static (as in static char postfix[1000];)
But the static array creates some re-entrancy problems.

The best approach is to supply the char pointer (and it's size) as parameters for maximum flexibility.

[crystalize123]

Thanks for your prompt reply.

[crystalize123]

Then can you or anyone knowledgeable tell me why the integer variable defined in the lpop function won't return NULL in the main function like the transition function in the thread, if both int data variable and char postfix[10000] variable are located in the stack region?

int data = node->data;
//...
return data;

//linked list based queue

typedef struct Node{
    int data;
    struct Node *next;
}Node;

typedef struct Queue{
    Node* front;
    Node* rear;
}Queue;

void lpush(Queue *queue, int data){
    Node *node = (Node*)malloc(sizeof(Node));
    node->data = data;
    Node* cur = queue->rear;
    if(cur == NULL){
        queue->front = node;
    }
    else{
        cur->next = node;
    }
    queue->rear = node;
    return;
}

int lpop(Queue *queue){

    Node* node = queue->front;
    int data = node->data;
    queue->front = node->next;
    free(node);
    return data;
}

int main()
{
    Queue queue;
    queue.front = NULL;
    queue.rear = NULL;
    lpush(&queue, 1);
    lpush(&queue, 2);
    lpush(&queue, 3);
    lpush(&queue, 4);
    lpush(&queue, 5);
    for(int i = 0; i < 5; i++){
        printf("%d\n",lpop(&queue ));
    }


    system("pause");
    return 0;
}

[Salem]

Because your int is a scalar, so you get a copy of the variable returned.

Whereas your postfix is an array, so the return is actually a pointer to the first element of the array.
In the same way you get a pointer to the first element when you pass an array parameter into a function.