return a reference

[emannion]

I am trying to clear up some reference questions

if I have a function that returns a reference to an int will that data
be lost when the function goes out of scope
int& retRef()
{
int j=10;

return j;
}

int main()
{

int& k = retRef();

int l = k;

return 0;
}

k is set to 10 after retRef() is called from main, I thought this
would not be possible if retRef() goes out of scope.

Can anyone answer this.

em

[Victor Bazarov]

em******@gmail.com wrote:

I am trying to clear up some reference questions

if I have a function that returns a reference to an int will that data
be lost when the function goes out of scope
int& retRef()
{
int j=10;

return j;
}

int main()
{

int& k = retRef();

int l = k;

return 0;
}

k is set to 10 after retRef() is called from main, I thought this
would not be possible if retRef() goes out of scope.

Any use of the returned reference has *undefined behaviour*, which
includes having what appears to be the actual intended effect. But
it is *undefined* nonetheless, IOW it may or may not even work the
next time run the same program on the same computer.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[=?iso-8859-1?b?VG9t4XMg0yBoyWlsaWRoZQ==?=]

emannion:

if I have a function that returns a reference to an int will that data
be lost when the function goes out of scope

Off hand, I can only think of four instances in which you'd return a
reference from a function:

1: int &Func() { return my_global_var; }

2: int &Func() { static int i; return i; }

3: int &Func() { return *new int; }

4: int &Func(SomeStruct ss) { return ss.i; }
Case 1 deals with global objects
Case 2 deals with static objects within functions
Case 3 deals with dynamically allocated objects
Case 4 deals with getting an object from the argument somehow

They're the "natural" cases that come to mind. Maybe if I thought about
it hard enough for a while, I could come up with another reason for
returning a reference from a function, but none come to mind instantly.

--
Tomás Ó hÉilidhe

[Andrey Tarasevich]

Tomás Ó hÉilidhe wrote:

...
Off hand, I can only think of four instances in which you'd return a
reference from a function:
...
Case 1 deals with global objects
Case 2 deals with static objects within functions
Case 3 deals with dynamically allocated objects
Case 4 deals with getting an object from the argument somehow
...

You forgot the case when it returns a reference to a data member of its
own object. But anyway, trying to enumerate these cases in such a
specific way is a waste of time. The important thing is they all have
the same common property: the object being referenced continues to exist
after the function exits.

--
Best regards,
Andrey Tarasevich

[kostas]

On Nov 30, 8:34 pm, Tomás Ó hÉilidhe <[e-mail]:

4: int &Func(SomeStruct ss) { return ss.i; }

you mean
4: int &Func(SomeStruct& ss) { return ss.i; }
of course.

regards
Kostas

[acehreli]

On Nov 30, 11:12 am, kostas <[e-mail]:

On Nov 30, 8:34 pm, Tomás Ó hÉilidhe <[e-mail]:

4: int &Func(SomeStruct ss) { return ss.i; }

you mean
4: int &Func(SomeStruct& ss) { return ss.i; }
of course.

No, no! Tomas is correct; because SomeStruct contains a reference to
an int, and has a trivial copy constructor! ;)

struct SomeStruct
{
int & i;

SomeStruct(int & i_)
:
i(i_)
{}
};

int &Func(SomeStruct ss) { return ss.i; }

#include <iostream>

int main()
{
int i = 42;

SomeStruct ss(i);
int & j = Func(ss);

std::cout << j << '\n';
}

The behavior is well defined. :)

Ali

[acehreli]

On Nov 30, 1:42 pm, [e-mail] wrote:
[...]

std::cout << j << '\n';

}

The behavior is well defined. :)

Actually no! If I'm not mistaken, the standard doesn't define whether
j will be flushed to cout without flushing std::cout (explicitly with
std::flush or possibly implicitly through std::endl). I love C++! :)

Ali

Ali

[=?iso-8859-1?b?VG9t4XMg0yBoyWlsaWRoZQ==?=]

kostas:

On Nov 30, 8:34 pm, Tomás Ó hÉilidhe <[e-mail]:

>4: int &Func(SomeStruct ss) { return ss.i; }

you mean
4: int &Func(SomeStruct& ss) { return ss.i; } of course.

Nice catch, thanks.

--
Tomás Ó hÉilidhe

[Rolf Magnus]

em******@gmail.com wrote:

if I have a function that returns a reference to an int will that data
be lost when the function goes out of scope

Not necessarily.

int& retRef()
{
int j=10;

return j;
}

In this case, yes. It's not exactly due to returing a reference, but rather
due to having a reference to an object that is already destroyed. j goes
out of scope as soon as retRef() returns.

int main()
{

int& k = retRef();

At this stage, there is no real error yet. Having a reference to a destroyed
object is ok, but you must not use it, so generally, returing a reference
to a local object makes no sense. However, returing a reference to an
object that lives longer than the function executes would be just fine.

int l = k;

This line invokes undefined behavior by using a reference to an object that
doesn't exist anymore.

return 0;
}

k is set to 10 after retRef() is called from main, I thought this
would not be possible if retRef() goes out of scope.

Well, the behavior is undedfined, which means anything can happen, including
things you don't expect.