473,287 Members | 1,501 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,287 software developers and data experts.

Returning a reference to a local variable

#include <iostream>
using namespace std;

double & GetWeeklyHours()
{
double h = 46.50;
double &hours = h;
return hours;
}
//---------------------------------------------------------------------------
int main()
{
double hours = GetWeeklyHours();

cout << "Weekly Hours: " << hours << endl;

return 0;
}
According to a (hopefully reliable) website, the above is correct
code.

Why is the above _not_ an example of the sin of "returning a reference
to a local variable"? What is the difference between the return-
reference-to-local problem and the above code?

Thanks,

Paul Epstein
Dec 30 '07 #1
7 6629
On Dec 29, 10:40 pm, pauldepst...@att.net wrote:
#include <iostream>
using namespace std;

double & GetWeeklyHours()
{
double h = 46.50;
double &hours = h;
return hours;}

//---------------------------------------------------------------------------
int main()
{
double hours = GetWeeklyHours();

cout << "Weekly Hours: " << hours << endl;

return 0;

}

According to a (hopefully reliable) website, the above is correct
code.

Why is the above _not_ an example of the sin of "returning a reference
to a local variable"? What is the difference between the return-
reference-to-local problem and the above code?
It is an example of undefined behaviour. A compiler is not required to
generate a diagnostic either.
Is it accepteable? Not in a long shot.
Here, try the following and pay attention to the output and sequence
of events.

#include <iostream>

class Hours
{
double m_d;
public:
Hours() : m_d(0.0) { std::cout << "Hours()\n"; }
Hours(double d) : m_d(d) { std::cout << "Hours(double)\n"; }
~Hours() { std::cout << "~Hours()\n"; }
Hours(const Hours& copy)
{
std::cout << "Hours(const Hours& copy)\n";
m_d = copy.m_d;
}
double get() const { return m_d; }
};

Hours& GetWeeklyHours()
{
Hours h = 46.50;
std::cout << "local initialized\n";
Hours& hours = h;
std::cout << "reference set\n";
return hours;
}

//---------------------------------------------------------------------------
int main()
{
Hours hours = GetWeeklyHours(); // is a copy (1)

std::cout << "Weekly Hours: " << hours.get() << std::endl;
}

/*
Hours(double)
local initialized
reference set
~Hours() // local destroyed here
Hours(const Hours& copy) // is a copy (1) of a reference
Weekly Hours: 6.95329e-310
~Hours()
*/

The basic rule of thumb is: if a local invokes a default or
parametized ctor, not a copy, it only lives in that scope.
It doesn't matter whether you use a reference, a 'reference to const'
or a 'pointer to const', the residual garbage left over from the
destruction of the local variable can't be guarenteed. Anything can
happen.

this is fine, btw:
Hours GetWeeklyHours()
{
return Hours(46.5);
}

but this is not:
Hours const& GetWeeklyHours()
{
return Hours(46.5);
}

Dec 30 '07 #2
On Dec 30, 1:00*pm, Salt_Peter <pj_h...@yahoo.comwrote:
On Dec 29, 10:40 pm, pauldepst...@att.net wrote:


#include <iostream>
using namespace std;
double & GetWeeklyHours()
{
* * double h = 46.50;
* * double &hours = h;
* * return hours;}
//-------------------------------------------------------------------------*--
int main()
{
* * double hours = GetWeeklyHours();
* * cout << "Weekly Hours: " << hours << endl;
* * return 0;
}
According to a (hopefully reliable) website, the above is correct
code.
Why is the above _not_ an example of the sin of "returning a reference
to a local variable"? *What is the difference between the return-
reference-to-local problem and the above code?

It is an example of undefined behaviour. A compiler is not required to
generate a diagnostic either.
Is it accepteable? Not in a long shot.
Here, try the following and pay attention to the output and sequence
of events.

#include <iostream>

class Hours
{
* double m_d;
public:
* Hours() : m_d(0.0) { std::cout << "Hours()\n"; }
* Hours(double d) : m_d(d) { std::cout << "Hours(double)\n"; }
* ~Hours() { std::cout << "~Hours()\n"; }
* Hours(const Hours& copy)
* {
* * std::cout << "Hours(const Hours& copy)\n";
* * m_d = copy.m_d;
* }
* double get() const { return m_d; }

};

Hours& GetWeeklyHours()
{
* Hours h = 46.50;
* std::cout << "local initialized\n";
* Hours& hours = h;
* std::cout << "reference set\n";
* return hours;

}

//-------------------------------------------------------------------------*--
int main()
{
* Hours hours = GetWeeklyHours(); // is a copy (1)

* std::cout << "Weekly Hours: " << hours.get() << std::endl;

}

/*
Hours(double)
local initialized
reference set
~Hours() // local destroyed here
Hours(const Hours& copy) // is a copy (1) of a reference
Weekly Hours: 6.95329e-310
~Hours()
*/

The basic rule of thumb is: if a local invokes a default or
parametized ctor, not a copy, it only lives in that scope.
It doesn't matter whether you use a reference, a 'reference to const'
or a 'pointer to const', the residual garbage left over from the
destruction of the local variable can't be guarenteed. Anything can
happen.

this is fine, btw:
Hours GetWeeklyHours()
{
* return Hours(46.5);

}

but this is not:
Hours const& GetWeeklyHours()
{
* return Hours(46.5);

}- Hide quoted text -

- Show quoted text -- Hide quoted text -

- Show quoted text -
Thanks, Peter. You seem to have put a lot of time and effort towards
helping me and I appreciate that. However, I'm still a bit confused.
I understand why your example code is bugged. The mystery (to me) is
why the code I posted originally _does not_ appear to suffer from the
reference-to-local bug. It works on my compiler, and was copied from
what seemed like a decent website. Are you saying that my original
code suffers from the same bug but that sometimes the local is
destroyed at a late enough time so that the original code still gives
correct results? My question is: Why does the original code give
reliable results even though it appears to return a reference to a
local?

Paul Epstein
Dec 30 '07 #3
On 2007-12-29 22:40:31 -0500, pa**********@att.net said:
#include <iostream>
using namespace std;

double & GetWeeklyHours()
{
double h = 46.50;
double &hours = h;
return hours;
}
//---------------------------------------------------------------------------
int main()
{
double hours = GetWeeklyHours();

cout << "Weekly Hours: " << hours << endl;

return 0;
}
According to a (hopefully reliable) website, the above is correct
code.
No. As far as I know, the standard makes no guarantee a behavior for
this code. This is no correct code.

BTW, please give the link to that website.

--

-kira

Dec 30 '07 #4
On Dec 30, 1:31*pm, Kira Yamato <kira...@earthlink.netwrote:
On 2007-12-29 22:40:31 -0500, pauldepst...@att.net said:


#include <iostream>
using namespace std;
double & GetWeeklyHours()
{
* * double h = 46.50;
* * double &hours = h;
* * return hours;
}
//-------------------------------------------------------------------------*--
int main()
{
* * double hours = GetWeeklyHours();
* * cout << "Weekly Hours: " << hours << endl;
* * return 0;
}
According to a (hopefully reliable) website, the above is correct
code.

No. *As far as I know, the standard makes no guarantee a behavior for
this code. *This is no correct code.

BTW, please give the link to that website.

--

-kira- Hide quoted text -

- Show quoted text -
Thanks Kira and Peter

The link is http://www.functionx.com/cpp/example...nreference.htm
The reason I was reluctant to include the link at the beginning is
that I didn't want to be seen as unfairly accusing the people who
designed the website.

Paul Epstein
Dec 30 '07 #5
On Dec 30, 12:31 am, pauldepst...@att.net wrote:
On Dec 30, 1:00 pm, Salt_Peter <pj_h...@yahoo.comwrote:
On Dec 29, 10:40 pm, pauldepst...@att.net wrote:
#include <iostream>
using namespace std;
double & GetWeeklyHours()
{
double h = 46.50;
double &hours = h;
return hours;}
//-------------------------------------------------------------------------*--
int main()
{
double hours = GetWeeklyHours();
cout << "Weekly Hours: " << hours << endl;
return 0;
}
According to a (hopefully reliable) website, the above is correct
code.
Why is the above _not_ an example of the sin of "returning a reference
to a local variable"? What is the difference between the return-
reference-to-local problem and the above code?
It is an example of undefined behaviour. A compiler is not required to
generate a diagnostic either.
Is it accepteable? Not in a long shot.
Here, try the following and pay attention to the output and sequence
of events.
#include <iostream>
class Hours
{
double m_d;
public:
Hours() : m_d(0.0) { std::cout << "Hours()\n"; }
Hours(double d) : m_d(d) { std::cout << "Hours(double)\n"; }
~Hours() { std::cout << "~Hours()\n"; }
Hours(const Hours& copy)
{
std::cout << "Hours(const Hours& copy)\n";
m_d = copy.m_d;
}
double get() const { return m_d; }
};
Hours& GetWeeklyHours()
{
Hours h = 46.50;
std::cout << "local initialized\n";
Hours& hours = h;
std::cout << "reference set\n";
return hours;
}
//-------------------------------------------------------------------------*--
int main()
{
Hours hours = GetWeeklyHours(); // is a copy (1)
std::cout << "Weekly Hours: " << hours.get() << std::endl;
}
/*
Hours(double)
local initialized
reference set
~Hours() // local destroyed here
Hours(const Hours& copy) // is a copy (1) of a reference
Weekly Hours: 6.95329e-310
~Hours()
*/
The basic rule of thumb is: if a local invokes a default or
parametized ctor, not a copy, it only lives in that scope.
It doesn't matter whether you use a reference, a 'reference to const'
or a 'pointer to const', the residual garbage left over from the
destruction of the local variable can't be guarenteed. Anything can
happen.
this is fine, btw:
Hours GetWeeklyHours()
{
return Hours(46.5);
}
but this is not:
Hours const& GetWeeklyHours()
{
return Hours(46.5);
}- Hide quoted text -
- Show quoted text -- Hide quoted text -
- Show quoted text -

Thanks, Peter. You seem to have put a lot of time and effort towards
helping me and I appreciate that. However, I'm still a bit confused.
I understand why your example code is bugged. The mystery (to me) is
why the code I posted originally _does not_ appear to suffer from the
reference-to-local bug. It works on my compiler, and was copied from
what seemed like a decent website. Are you saying that my original
code suffers from the same bug but that sometimes the local is
destroyed at a late enough time so that the original code still gives
correct results? My question is: Why does the original code give
reliable results even though it appears to return a reference to a
local?

Paul Epstein
First off - you may very well find others to have a different point of
view than mine.
You might even find a compiler with some scheme that makes the above
work with primitives (stored in a register? who knows - i really don't
care).

The fact remains, once the scope ends:
a) the local variable is no more
b) that area of memory is therefore left unprotected (its writeable)

So if you have a busy program (multi-threaded, etc)... its only a
question of time.
Debugging an issue that only happens intermittently is near
impossible. Testing for UB is easy comparatively.

A completely different Issue...
The standard specifically says you can't bind a 'reference to non-
const' to a temporary. Many beleive this means that its ok to *return*
a local through a reference to const. Well, not quite. The standard,
as i understand it, says this:

void DisplayHours(const double& ref) // must be a ref to const
{
std::cout << ref << std::endl;
}

int main()
{
DisplayHours(double(99));
}

The above works because double(99), a temporary, has a lifetime that
lasts until the function ceases to exist.
That, by the way, is the better way to write your GetWeeklyHours
function, pass the variable by reference_to_const which safely
modifies the original. At least thats guarenteed 100% of the time.

Hopefully, a little light was thrown on this and if not, someone else
can give it a go.
Dec 30 '07 #6
pa**********@att.net wrote:
#include <iostream>
using namespace std;

double & GetWeeklyHours()
{
double h = 46.50;
double &hours = h;
return hours;
}
//---------------------------------------------------------------------------
int main()
{
double hours = GetWeeklyHours();

cout << "Weekly Hours: " << hours << endl;

return 0;
}
According to a (hopefully reliable) website, the above is correct
code.

Why is the above _not_ an example of the sin of "returning a reference
to a local variable"? What is the difference between the return-
reference-to-local problem and the above code?
As I understand it, the example code works because RVO constructs the
local variable at the site of main's 'hours' variable.

Without RVO, the above code would not work, and RVO cannot be guaranteed.
Dec 30 '07 #7
Daniel T. wrote:
>
As I understand it, the example code works because RVO constructs the
local variable at the site of main's 'hours' variable.

Without RVO, the above code would not work, and RVO cannot be guaranteed.
Well more likely, the RVO just causes the copy to the main:hours
variable before the GetWeeklyHours:h is obliterated.

One of those insidious forms of undefined behavior is things appear to
work normally, TODAY.
Dec 30 '07 #8

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

6
by: Krackers | last post by:
How do you write a function which returns a reference to an array. I can only get a function to return a copy of the array itself. I've had a look at some other threads in this group an the return...
1
by: Andrew Fleet | last post by:
Hi, I'm looking at returning a reference to an array I create within a subroutine. I could do this... sub foo { my @theArray; <snip>
7
by: Dr John Stockton | last post by:
What are the best ways of returning multiple results from a subroutine ? I've been using ... return } which is inelegant. I'm used to Pascal's procedure X(const A, B : integer; var C, D :...
12
by: Olumide | last post by:
I'm studying Nigel Chapman's Late Night Guide to C++ which I think is an absolutely fantastic book; however on page 175 (topic: operator overlaoding), there the following code snippet: inline...
5
by: Alfonso Morra | last post by:
Hi, What is the recomended way of returning an STL container (e.g. std::string, std::vector etc fom a function? Is it by simply returning a local variable? (I doubt it) std::string...
17
by: djcredo | last post by:
Hey all, I want to return a pointer to a struct. Here is what I'lm trying to do: struct Position{ int x; int y; }; Position* GraphicTag::getRenderCentre(){
11
by: ravi | last post by:
Can anybody out there tell me whether it i possible to return a reference from a function in C++ I am using Turbo C++
23
by: pauldepstein | last post by:
Below is posted from a link for Stanford students in computer science. QUOTE BEGINS HERE Because of the risk of misuse, some experts recommend never returning a reference from a function or...
8
by: darren | last post by:
Hi everybody, have a quick look at this code: ===== ===== int main(void) { string msg; makeString(msg); cout << "back in main, result = " << msg << endl;
2
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 7 Feb 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:30 (7.30PM). In this month's session, the creator of the excellent VBE...
0
by: MeoLessi9 | last post by:
I have VirtualBox installed on Windows 11 and now I would like to install Kali on a virtual machine. However, on the official website, I see two options: "Installer images" and "Virtual machines"....
0
by: DolphinDB | last post by:
The formulas of 101 quantitative trading alphas used by WorldQuant were presented in the paper 101 Formulaic Alphas. However, some formulas are complex, leading to challenges in calculation. Take...
0
by: ryjfgjl | last post by:
ExcelToDatabase: batch import excel into database automatically...
0
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
0
by: marcoviolo | last post by:
Dear all, I would like to implement on my worksheet an vlookup dynamic , that consider a change of pivot excel via win32com, from an external excel (without open it) and save the new file into a...
1
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
0
by: ArrayDB | last post by:
The error message I've encountered is; ERROR:root:Error generating model response: exception: access violation writing 0x0000000000005140, which seems to be indicative of an access violation...
1
by: PapaRatzi | last post by:
Hello, I am teaching myself MS Access forms design and Visual Basic. I've created a table to capture a list of Top 30 singles and forms to capture new entries. The final step is a form (unbound)...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.