为什么这个函数返回垃圾值

Question

I was writing a program and facing this problem that the following function used to return garbage values:

int* foo(int temp){
   int x = temp;
   return &x;
}

When I modified it to this, it worked fine:

int* foo(int *temp){
    int *x = temp;
    return x
}

What was wrong with the first version?

Answer 1

The first version returns a reference to a local variable x whose storage is limited to the function foo . When the function exits, x can no longer be used. Returning a reference to it is one instance of a dangling pointer .

In the second version, you're really only passing in and returning the same pointer value, which refers to memory which isn't limited by the lifetime of the function. So even after the function exits, the returned address is still valid.

Another alternative:

int *foo(int temp)
{
    int *x = malloc(sizeof(int));
    *x = temp;
    return x;
}

Answer 2

For each function there will be an activation record, which will be created in stack once the execution of that function starts. Activation record holds all the local variables also. And this activation record will be freed once the function execution finishes.

So if we return an address of a local variable means, that will be freed memory of previous function`s activation record. Dereferencing that memrory is an undefined behaviour.

In the below case, function foo is returning the &x that means p will holds the address of func 's local variable x . This is valid. But if function func tries to retrun p (address of x ) which is not valid.

int* func
{
   int x;
   int *p;
   ...
   p = foo(&x);
   //using p is valid here
   ...
   return p; //This is invalid
}

int* foo(int *temp)
{
   int *x = temp;
   return x //This is valid
}

In the below case, funciton foo is returning address of its local variable x to function func . So p will holds address of foo 's local variable. So deferencing p is invalid because foo functions execution has been completed and its activation record is freed.

int* func
{
   int x;
   int *p;
   ...
   p = foo(x);
   //using p is invalid here
   ...
   return p; //This is invalid
}

int* foo(int temp)
{
   int x = temp;
   return &x; //This is also invalid
}