What could be the possible reason behind the warning which comes up when the following piece of code is compiled

This is a simple piece of code which i wrote to check whether it is legitimate to return the address of a local variable and my assumptions were proved correct by the compiler which gives a warning saying the same:

warning: function returns address of local variable

But the correct address is printed when executed... Seems strange!

#include<stdio.h>
char * returnAddress();
main()
{
    char *ptr;
    ptr = returnAddress();
    printf("%p\n",ptr);
}

char * returnAddress()
{
    int x;
    printf("%p\n",&x);
    return &x;
}

The behaviour is undefined.

Anything is allowed to happen when you invoke undefined behaviour - including behaving semi-sanely.

The address of a local variable is returned. It remains an address; it might even be a valid address if you're lucky. What you get if you access the data that it points to is anyone's guess - though you're best off not knowing. If you call another function, the space pointed at could be overwritten by new data.

You should be getting warnings about the conversion between int pointer and char pointer - as well as warnings about returning the address of a local variable.

What you are trying to do is usually dangerous:

In returnAddress() you declare a local, non-static variable i on the stack. Then you return its address which will be invalid once the function returned. Additionally you try to return a char * while you actually have an int *.

To get rid of the warning caused by returning a pointer to a local var, you could use this code:

void *p = &x;
return p;

Of course printing it is completely harmless but dereferencing (e.g. int x = *ptr;) it would likely crash your program.

However, what you are doing is a great way to break things - other people might not know that you return an invalid pointer that must never be dereferenced.

Yes, the same address is printed both times. Except that, when the address is printed in main(), it no longer points to any valid memory address. (The variable x was created in the stack frame of returnAddress(), which was scrapped when the function returned.)

That's why the warning is generated: Because you now have an address that you must not use.

Because you can access the memory of the local variable, doesn't mean it is a correct thing to do. After the end of a function call, the stack pointer backtracks to its previous position in memory, so you could access the local variables of the function, as they are not erased. But there is no guaranty that such a thing won't fail (like a segmentation fault), or that you won't read garbages.

Which warning? I get a type error (you're returning an int* but the type says char*) and a warning about returning the address of a local variable.

The type error is because the type you've declared for the function is lies (or statistics?).

The second is because that is a crazy thing to do. That address is going to be smack in the middle (or rather, near the top) of the stack. If you use it you'll be stomping on data (or have your data stomped on by subsequent function calls).

Its not strange. The local variables of a function is allocated in the stack of that function. Once the control goes out of the function, the local variables are invalid. You may have the reference to the address but the same space of memory can be replaced by some other values. This is why the behavior is undefined. If you want reference a memory throughout your program, allocate using malloc. This will allocate the memory in heap instead of stack. You can safely reference it until you free the memory explicitly.

#include<stdio.h>
#include<stdlib.h>
char * returnAddress();
main()
{
    char *ptr;
    ptr = returnAddress();
    printf("%p\n",ptr);
}

char * returnAddress()
{
    char *x = malloc(sizeof(char));
    printf("%p\n",x);
    return x;
}