Reference return value and value updation in destructor

Question

#include <iostream>
using namespace std;

int i; //1 - global

class Test
{
public:
    ~Test()
    {
        i = 10;
    }
};

int& foo()
{
    int i = 3; //2 - local
    Test ob;
    return i;
}

int main()
{
    cout << "i = " << foo() << endl; // output: i = 3
    return 0;
}

I have queries for above code:

Variable i being local to foo, reference of which cannot be used (automatic variable). How does above code execute?
The Test object in foo function will be destroyed after return statement. How does foo function returns reference of 2 (i = 3)?

`i = 3;` (and `i = 10;`) does not declare a new variable, it still uses the global one — UnholySheep, Jun 15 '18 at 16:30
Welcome to undefined behavior land, where invalid code don't necessarily crashes. — Guillaume Racicot, Jun 15 '18 at 16:43
@UnholySheep.. tried here http://cpp.sh/6uhbc (output i =3, each run) — Vishvajeet T, Jun 15 '18 at 16:47
And on IDEOne it causes a runtime error: https://ideone.com/5hKuFd - just because one compiler creates code that "works" does not mean your code is correct — UnholySheep, Jun 15 '18 at 16:48
Also if I change the optimization level in the link you provided the result changes as well (your tests weren't very thorough) — UnholySheep, Jun 15 '18 at 16:50
@VishvajeetT the standard simply says that reading or writing into a dead object is undefined behavior. It's up to the implementation to decide how to behave. In that case, there is no runtime check done to see if the variable is dead. If it happen to work, it does. If it happen to crash, so be it. I recommend you to use a "undefined behavior sanitizer", which will add those runtime checks for you to debug your code. — Guillaume Racicot, Jun 15 '18 at 16:56

score 4 · Answer 1 · answered Jun 15 '18 at 16:48

Variable i being local to foo, reference of which cannot be used (automatic variable). How does above code execute?

What you are doing is cause for undefined behavior. Unfortunately, seemingly sane behavior falls under undefined behavior too. A legendary answer on SO expounds on the subject.

The Test object in foo function will be destroyed after return statement. How does foo function returns reference of 2 (i = 3)?

The first statement is correct. However, that is not relevant to the issue of which i is returned from foo. foo returns a reference to the function local variable regardless of what Test does.

@VishvajeetT, when I read that answer the first time, I was awe struck. What a great analogy to explain undefined behavior! — R Sahu, Jun 15 '18 at 17:07

score 2 · Answer 2 · answered Jun 15 '18 at 16:30

2

You always read and wrote the global i since you never declared local i or class member i in your code.

answered Jun 15 '18 at 16:30

timrau

22,578
4
51
64

This _was_ a correct answer to the posted question. Now the question has been edited to ask what I believe is a follow-up question. – Drew Dormann Jun 15 '18 at 16:51

Achal · Answer 3 · 2018-06-15T16:49:09.497

when you call foo() like

cout << "i = " << foo() << endl;

This block of code will execute

int& foo() {
    i = 3; //2 - local
    Test ob; /* object having local scope */
    return i;
}/* when it goes out of this block.. destructor gets called */

above you are creating object ob. when it came out of scope, destructor ~Test() { } gets called automatically & in destructor you have i=10, so return i; will return i value which was there in destructor. so it prints i value as 10. Also i = 3; doesn't create new i it will consider global declared i.

updated code :

int& foo() {
    int i = 3; /* here i is locally created */
    Test ob;
    return i; /* you can't return reference to local variable.. invokes UB */
}

Above code block will cause undefined behavior.

Reference return value and value updation in destructor

3 Answers3