Is malloc needed for this int pointer example?

Question

The following application works with both the commented out malloced int and when just using an int pointer to point to the local int 'a.' My question is if this is safe to do without malloc because I would think that int 'a' goes out of scope when function 'doit' returns, leaving int *p pointing at nothing. Is the program not seg faulting due to its simplicity or is this perfectly ok?

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

typedef struct ht {
    void *data;
} ht_t;

ht_t * the_t;

void doit(int v)
{
    int a = v;
    //int *p = (int *) malloc (sizeof(int));
    //*p = a;
    int *p = &a;

    the_t->data = (void *)p;
}

int main (int argc, char *argv[])
{
    the_t = (ht_t *) malloc (sizeof(ht_t));
    doit(8);
    printf("%d\n", *(int*)the_t->data);
    doit(4);
    printf("%d\n", *(int*)the_t->data);
}

[Don't cast the result of `malloc()`](http://stackoverflow.com/questions/605845/do-i-cast-the-result-of-malloc) — Iharob Al Asimi, Feb 19 '15 at 17:58

score 5 · Accepted Answer · answered Feb 19 '15 at 17:57

5

Yes, dereferencing a pointer to a local stack variable after the function is no longer in scope is undefined behavior. You just happen to be unlucky enough that the memory hasn't been overwritten, released back to the OS or turned into a function pointer to a demons-in-nose factory before you try to access it again.

answered Feb 19 '15 at 17:57

IllusiveBrian

3,105
2
14
17

4

Did you mean: "You are just unlucky enough that your implementation in this context does not crash"? – Deduplicator Feb 19 '15 at 17:58
2

@Deduplicator Yes, but I figured giving a few examples of what other problems he might run into could be helpful. – IllusiveBrian Feb 19 '15 at 18:00

score 3 · Answer 2 · answered Feb 19 '15 at 17:58

Not every UB (undefined behaviour) results in a segfault.

Normally, the stack's memory won't be released back to the OS (but it might!) so that accessing that memory works. But at the next (bigger) function call, the memory where the pointer points to might be overwritten, so your data you felt like bing safe there is lost.

score 1 · Answer 3 · answered Feb 19 '15 at 18:04

1

malloc() inside a function call will work because it stores on heap. The pointer remains until you free the memory.

And yes, not every undefined behaviour will result in segmentation fault.

answered Feb 19 '15 at 18:04

Vamsi

878
1
8
25

score 0 · Answer 4 · edited May 23 '17 at 12:12

It does not matter that p does not point at anything on return from doit.
Because, you know, p isn't there any more either.

It does matter that you are reading the pointer to a no-longer-existing object in main though. That's UB, but harmless on most modern platforms.
Even worse though, you are reading the non-existent object it once pointed to, which is straight Undefined Behavior.

Still, nobody is obliged to catch you:
Can a local variable's memory be accessed outside its scope?

As an aside, Don't cast the result of malloc (and friends).
Also, be aware that not free-ing memory is not harmless on all platforms: Can I avoid releasing allocated memory in C with modern OSes?

score 0 · Answer 5 · answered Feb 19 '15 at 18:02

Yes, the malloc is needed, otherwise the pointer would point on the 4-byte space of the stack, which would be used by other data, if you called other functions or created now local variables.

You can see that if you call that function afterwards with a value of 10:

void use_memory(int i)
{
    int f[128]={};
    if(i>0)
    {
        use_memory(i-1);
    }
}

Is malloc needed for this int pointer example?

5 Answers5