Why do I get a problem when I return a memory address of a variable as opposed to returning a pointer of it?

Here's my code:

    struct Node* createNode(void* value) {
        struct Node node = {.val = value, .next = NULL};
        //struct Node* temp = &node;
        return &node;
    }

struct Node:

    struct Node {
        void* val;
        struct Node* next;
    };

When I return &node, I get an error stating "address of stack memory associated with local variable 'node' returned"

I tried return a pointer pointing to node and the problem went away. I get that node is stored in the stack memory; however, why don't I get the same error when I return temp since it also points to the stack memory?

Variables in C have storage durations.

Your variable has automatic storage duration and it stops to exist when you leave the scope it was defined in. When you try to return reference (pointer) to it that pointer is referencing the object which does not exist anymore. It invokes undefined behaviour.

Your variable has to have allocated or static storage duration to prevent invoking UB

    struct Node* createNode(void* value) {
        struct Node *node = malloc(sizeof(*node));
        *node = (struct Node){.val = value, .next = NULL};
        return node;
    }

or (not a greatest idea):

    struct Node* createNode(void* value) {
        static struct Node node;
        node = (struct Node){.val = value, .next = NULL};
        return &node;
    }

> why don't I get the same error when I return temp since it also points
> to the stack memory?

Because you do not return the reference to the local variable, only the value of pointer temp. It may or may not contain a reference to the local variable. The compiler needs to analyze your code. In this trivial case if you enable optimizations (and it forces the compiler to take a deeper look) it will warn. But if the code is more complicated the compiler might not be able to determine it.

https://godbolt.org/z/Yj77MKqq4

The warning for this:

struct Node* createNode(void* value) {
    struct Node node = {.val = value, .next = NULL};
    return &node;
}

is because node is known to be on the stack, and the use of a pointer to that will lead to undefined behaviour.

The lack of warning for this, which is what I think you are asking about:

struct Node* createNode(void* value) {
    struct Node node = {.val = value, .next = NULL};
    struct Node* temp = &node;
    return temp;
}

is that whilst it is clear that temp points to a structure on the stack, since it is a pointer (and not the address of a variable), it could conceivably point to something else.

For the compiler to detect the same problem, it would have to implement some kind of tracking of values that are probably not worth it in general terms.

In all cases, whether you get a warning / error or not, returning the address of an automatic variable on the stack (and then using it) will lead to undefined behaviour. Don't do it - finding a way to silence the compiler warning does not make it safe.

That is a really good warning.

When you return the address of a local variable, the return value is clearly nonsensical as the variable does not exist anymore.

When compiling at sufficiently low optimization level, the compiler won't catch you doing it through a variable. (In general it's an unsolvable problem so in convoluted enough code it won't anyway.)

You want

    struct Node* createNode(void* value) {
        struct Node *node = malloc(sizeof(struct node));
        node->val = value;
        node->next = NULL;
        return node;
    }

This puts it on the heap so it doesn't go away.

Don't forget to call free(node) in the calling function (or it's caller, etc.) when you're done with it.