Returning a reference to a local or temporary variable

Question

Look at the code below. I know it doesn't return the address of local variable, but why does it still work and assign the variable i in main() to '6'? How does it only return the value if the variable was removed from stack memory?

#include <iostream>

int& foo()
{
    int i = 6;
    std::cout << &i << std::endl; //Prints the address of i before return
    return i;
}

int main()
{
    int i = foo();
    std::cout << i << std::endl; //Prints the value
    std::cout << &i << std::endl; //Prints the address of i after return
}

You may find this useful: http://stackoverflow.com/questions/6441218/can-a-local-variables-memory-be-accessed-outside-its-scope — letsc, Jun 30 '11 at 16:27
I believe some luck is in the fact that i is unaltered in foo() (which allows compilers to place in text or somewhere long-lived instead of stack) — Om Deshmane, Apr 03 '12 at 09:45
Obtaining an address from a local variable will probably prevent the compiler/runtime from using a register for it. With the result of poor performance. — , Jan 02 '13 at 11:44

score 24 · Accepted Answer · answered Apr 30 '10 at 11:54

24

You got lucky. Returning from the function doesn't immediately wipe the stack frame you just exited.

BTW, how did you confirm that you got a 6 back? The expression std::cout << &i ... prints the address of i, not its value.

answered Apr 30 '10 at 11:54

Marcelo Cantos

181,030
38
327
365

3

the 6 comes out when he prints it in main(). – San Jacinto Apr 30 '10 at 11:59
2

@San: Well, it does now that @Dave18 edited the question. – Marcelo Cantos Apr 30 '10 at 12:14
1

Sorry, I must have read the question after this :) – San Jacinto Apr 30 '10 at 12:16
One more point, the aftermath of a fuction call is compiler dependent. Usually GCC doesnt modify any values on the stack(and hence, we still get our old values). However compilers like Dev C++ modify the values(though I dont see a reason why it does so) and if you try accessing any values later, you simply get a garbage value!! – letsc Jun 30 '11 at 16:25
@smartmuki: Good point! Additionally, I believe debug compilations sometimes balkanise the stack on the way out in order to highlight access to out-of-scope variables. – Marcelo Cantos Jun 30 '11 at 22:25
I wouldn't call that luck. Quite the opposite. He was unlucky that UB worked as he expected. – BЈовић May 18 '12 at 09:52
any possibility of segmentation fault here ? – Debashish Aug 24 '16 at 09:39
@Debashish no, there isn't, unless a cosmic ray flips a bit, I suppose. – Marcelo Cantos Aug 24 '16 at 09:55

score 3 · Answer 2 · answered Apr 30 '10 at 11:57

3

Must be something your compiler is doing.

http://www.learncpp.com/cpp-tutorial/74a-returning-values-by-value-reference-and-address/

Confirms that your example will remove the reference from stack memory.

answered Apr 30 '10 at 11:57

NeuroScr

322
1
7

score 3 · Answer 3 · edited May 23 '17 at 12:07

3

Returning reference or pointer to a local variable is undefined behavior. Undefined behavior means, the standard leaves the decision to the compiler. That means, undefined behavior sometimes works well, and sometimes it doesn't.

edited May 23 '17 at 12:07

Community

1
1

answered Apr 30 '10 at 13:00

Björn Pollex

75,346
28
201
283

4

And the chances of it not working well depend on the importance of the people watching the demo. – KeithB Apr 30 '10 at 13:28

score 2 · Answer 4 · answered Apr 30 '10 at 14:24

The address of i is never going to change in main(), but the value contained therein will. You are taking the reference of a local variable and using it after that reference has fallen out of scope. (Imprecise language warning) The value 6 is on the stack. Since you didn't do anything with the stack after you put 6 there, the reference to it will still contain the same value. So, as others have said, you got lucky.

To see just how lucky, try running this code which uses the stack after you call foo():

#include <iostream>
#include <ctime>
#include <numeric>

int& foo()
{
    int i = 6;
    std::cout << &i << " = " << i << std::endl; //Prints the address of i before return
    return i;
}

long post_foo(int f)
{
    srand((unsigned)time(0));

    long vals[10] = {0};
    size_t num_vals = sizeof(vals)/sizeof(vals[0]);
    for( size_t i = 0; i < num_vals; ++i )
    {
        int r = (rand()%2)+1;
        vals[i] = (i+f)*r;
    }

    long accum = std::accumulate(vals, &vals[num_vals], 0);
    return accum * 2;
}

int main()
{
    int &i = foo();
//  std::cout << "post_foo() = " << post_foo(i) << std::endl;
    std::cout << &i << " = " << i << std::endl; 
}

When I ran this with the post_foo() call commented out, 6 was still on the stack and the output was:

002CF6C8 = 6
002CF6C8 = 6

...but when I un-commented the call to post_foo() and ran it again, 6 was long gone:

001FFD38 = 6
post_foo() = 310
001FFD38 = 258923464

score 1 · Answer 5 · answered Apr 30 '10 at 12:30

While your function returns an integer by reference it is immediately assigned to the local variable 'i' in main(). That means that the stack memory allocated for foo() must persist just long enough for the return assignment. While it's bad form, this usually works. If you had tried to keep a reference

int &i = foo();

it would be much more likely to fail.

Returning a reference to a local or temporary variable

5 Answers5

Linked

Related