从另一个函数内部返回本地malloc（）指针

Question

I'm going through some lecture slides from Princeton University and have a question. The professor has this code snippet (on slide 8 there):

struct Table *Table_create(void) {
 struct Table *t;
 t = (struct Table*)malloc(sizeof(struct Table));
 t->first = NULL;
 return t;
} 

struct Table *t;
…
t = Table_create();
… 

In the Table_crate() function, even though t is allocated using malloc , t itself would be located on the stack, correct?.

So, can you return t from this function? I'd think t in Table_create() would disappear as soon as the function returns.

Answer 1

The variable t has automatic storage duration. But that doesn't prevent you from returning its value from the function. The value itself (ie the pointer returned by malloc() ) has the lifetime of the program (or until you call free() on it). So, it's not an issue to return the malloc() 'ed value from a function.

If it helps, consider this:

int func(int num)
{
    int val;
    val = num * 2; //  take care of signed integer overflow!
    return val;
}

Does returning val here has anything to do with the lifetime of val (which is a local variable and has automatic storage duration)? No. This is analogous to malloc() code you have.

Answer 2

The variable t lives on the stack, but the thing it points to (via the call to malloc ) lives on the heap.

When you return t you are returning it's value, which is the address on the allocated memory. This is then assigned to a local variable in the caller. If you hadn't assigned it in the caller you would have a memory leak. At some point you will need to call free in order to release the memory and avoid the memory leak.

Answer 3

是的，您可以返回存储在 t 的值，因为该值已被复制到调用方，但是您不应返回指向 t 指针或引用，因为t将会消失并且此类指针或引用是无用的。

Answer 4

t would not be on the stack. You can return t from the function. malloc will remember the allocated memory until you call free