当我错过 C 中的动态内存分配时，为什么我不会收到编译错误？

Question

Let's suppose I am trying to write a function that creates a simple linked list in C.

The function is like this:

node* createLinkedList(int n) {

    int i = 0;
    node* head = NULL;
    node* temp = NULL;
    node* p = NULL;

    for (i = 0; i < n; i++) {

        //create isolated node

        temp = malloc(sizeof(node));
        printf_s("\nEnter the data for node number %i:", i);
        scanf_s("%d", &(temp->data));
        temp->next = NULL;

        if (head == NULL) {
            //if list is empty then make temp as first node
            head = temp;
        }
        else {
            p = head;
            while (p->next != NULL)
                p = p->next;
            p->next = temp;
        }
    }
    return head;
}

If I purposely delete the line temp = malloc(sizeof(node)); the program compile just fine but I get a runtime error (obviously).

My question is: Shouldn't the compiler warn me that I did not allocate memory for the temp variable? Is it allocating that memory implicitly? If so, how?

Answer 1

By definition, malloc doesn't allocate memory implicitly. It's the purpose of this function to return a valid memory address, which obviously can't be verified by the compiler as it will be called during runtime.

At this point, the compiler just assumes that the pointer is a valid one. It can't guess if the pointer is already pointing to a valid memory address or not.

Answer 2

Shouldn't the compiler warn me that I did not allocate memory for the temp variable?

Nope. The allocation is done during runtime. The best the compiler can do is to warn you if an variable is not initialized. And this is the reason why I think it's a bad idea to initialize pointers to NULL;

$ cat main.c
int main(void)
{
    int *p;
    *p =42;
}

$ gcc main.c -Wall -Wextra
main.c: In function ‘main’:
main.c:4:8: warning: ‘p’ is used uninitialized in this function [-Wuninitialized]
    4 |     *p =42;
      |     ~~~^~~

If you change int *p; to int *p = NULL; you will not get that warning.

To simplify it a bit. The compiler has absolutely no idea whatsoever about allocation. The return value from malloc is simply an address. In that regard, these three statements are not fundamentally different:

int *p = NULL;
int *p = &k;
int *p = malloc(sizeof *p); 

In all three cases, p is assigned the value of an address. The compiler has no way to know if that address points to a valid memory address or not.