Why does the c++ variable not get detleted immediately?

Question

I'd like to know why is it that the data that is pointed to when you return from a function, is not deleted immediately. In the snippet of code below,I expect that when I return the address of x to the pointer to initialise it when returning from function, the data stored in the address of x should be deleted immediately. However I am still able to get the correct value in main and then only after one more line of code does it suddenly turn into garbage? Why does this not happen immediately

int* function(int x)
{
    cout << x << endl; // This outputs 5 as expected
    return &x;
}

int main()
{
    int* a = function(5);


    cout << *a; // This still outputs 5. Why?
    cout << endl;

    cout << *a; // It is garbage here as expected
    cout << endl;

    return 0;
}

Thanks

Variables are not deleted. Their values might become deleted. — Basile Starynkevitch, Nov 12 '14 at 12:17
@Niall Even if it did: it wouldn't apply to local variables (at least in C++), and of course, garbage collection won't recycle the memory until it's needed. — James Kanze, Nov 12 '14 at 12:17
As soon as x goes out of scope, accessing its contents is undefined as the location that stores them may be re-used. That doesn't mean they _are_ reused immediately -it can happen immediately, after a while or never — The Archetypal Paul, Nov 12 '14 at 12:18
My [answer](http://stackoverflow.com/a/26705204/509868) to another similar question may help you. — anatolyg, Nov 12 '14 at 12:19

SingerOfTheFall · Accepted Answer · 2014-11-12T12:24:16.467

2

Returning the address of a local variable invokes undefined behavior. So, you're just lucky.

The local variable (allocated on the stack) gets deleted when it leaves it's scope, which in your case is when function() ends. However, after the variable leaves the scope, the memory it occupies is not rewritten immediately and unless that memory is reused the value of x will stay there.

Since it invokes UB, your attempt to read the contents of that memory can result in reading the right value, reading garbage, your programm crashing, or anything else.

edited Nov 12 '14 at 12:24

answered Nov 12 '14 at 12:15

SingerOfTheFall

29,228
8
68
105

Or unlucky, as the case may be :) – Scott Hunter Nov 12 '14 at 12:15
That's not an answer to the question, which is about the timing of garbage collection. – The Archetypal Paul Nov 12 '14 at 12:15
@Paul, well, because there is no garbage collection at all? – SingerOfTheFall Nov 12 '14 at 12:16
There is. There's no automatic garbage collection, but there's recycling of storage. Maybe I should have used a different term – The Archetypal Paul Nov 12 '14 at 12:17
@Paul: The question doesn't mention garbage collection. It asks why the dead variable doesn't immediately have a garbage value. The answer is UB (although a better answer would also explain that the apparent value is unlikely to change until the storage is reused). – Mike Seymour Nov 12 '14 at 12:17
OK, wrong term. I was trying to make the point that he question is about storage recycling, not about whether the behaviour is defined – The Archetypal Paul Nov 12 '14 at 12:19

score 1 · Answer 2 · answered Nov 12 '14 at 12:16

1

Returning address of local variable is undefined. Undefined means you can't predict whether it would output correct OR incorrect result. It's unfortunate that you got correct result.

answered Nov 12 '14 at 12:16

ravi

10,994
1
18
36

score 0 · Answer 3 · answered Nov 12 '14 at 12:19

0

As you should not be accessing such "garbage" (a technical term), the system is free to deal with it as it sees fit. For example, there may have been other tasks whose completion would have affected correctly-written programs.

answered Nov 12 '14 at 12:19

Scott Hunter

48,888
12
60
101

score 0 · Answer 4 · answered Nov 12 '14 at 12:22

When you return the address of a local variable, the resulting pointer "dangles"; accessing through a dangling pointer, or even just reading it, is undefined behavior. Which means that in theory, anything can happen. In practice, the compiled code won't return the memory of the local variables in the function to the OS; in most OS's, it couldn't even if it wanted to. So the memory just sits there, until someone else uses it. In the case of memory in a function, it will be reused when you call another function; until then, you will probably be able to access it and find the old values. Debugging builds might intentionally scribble over the memory on leaving the function, but the mainstream compilers don't do this. And of course, programs like valgrind might check that the pointer is valid, and log an error (but I don't know if valgrind actually catches this).

Why does the c++ variable not get detleted immediately?

4 Answers4