Returning by value, returning by reference

[JKop]

When I compile and run the following on my system:
#include <iostream>

static int hello = 78;
int ReturnValue(voi d)
{
return hello;
}
int& ReturnRef(void)
{
return hello;
}
int main(void)
{
const int& value = ReturnValue();

const int& ref = ReturnRef();

if ( &value == &ref )
{
std::cout << "They're the same!!" << std::endl;
}
else
{
std::cout << "They're different!!" << std::endl;
}

std::system("pa use");

}
, it prints "They're different". I'm curious as to why?!
I was thinking along these lines at first:

You can bind a temporary returned from a function to a reference. Therefore,
it's just the same as the function returning by reference, except that it's
const.

As such, I expected the output to be "They're the same!!".
Any thoughts?
-JKop

[JKop]

JKop posted:

When I compile and run the following on my system:
#include <iostream>

static int hello = 78;
int ReturnValue(voi d)
{
return hello;
}
int& ReturnRef(void)
{
return hello;
}
int main(void)
{
const int& value = ReturnValue();

const int& ref = ReturnRef();

if ( &value == &ref )
{
std::cout << "They're the same!!" << std::endl;
}
else
{
std::cout << "They're different!!" << std::endl;
}

std::system("pa use");

}
, it prints "They're different". I'm curious as to why?!
I was thinking along these lines at first:

You can bind a temporary returned from a function to a reference.
Therefore, it's just the same as the function returning by reference,
except that it's const.

As such, I expected the output to be "They're the same!!".
Any thoughts?
-JKop

Another thought:

A function that returns a const reference.
A function that returns by value.
int Monkey(void)
{
int monkey = 72;

return monkey;
}
const int& Ape(void)
{
int ape = 72;

return ape;
}
They're exactly the same, right? There shouldn't be any difference, eg. an
extra temporary made.
-JKop

[Ivan Vecerina]

"JKop" <NU**@NULL.NULL > wrote in message
news:6q******** *********@news. indigo.ie...
....

const int& value = ReturnValue(); .... You can bind a temporary returned from a function to a reference. Therefore, it's just the same as the function returning by reference, except that it's const.

Not the same actually.
The story is more like: the function returned the copy of a value,
eventually stored on the stack. By using a const reference, we are
trying to tell the compiler to avoid copying the value again into
a local variable, and to extend the lifetime of the temporary it
stores a reference to.

The original variable whose copy was returned by "ReturnValu e()"
is never accessible from the outside.
hth
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- e-mail contact form
Brainbench MVP for C++ <> http://www.brainbench.com

[Rob Williscroft]

JKop wrote in news:6q******** *********@news. indigo.ie in comp.lang.c++:

When I compile and run the following on my system:
#include <iostream>

static int hello = 78;
int ReturnValue(voi d)
{
This Function returns a *copy* of 'hello'.
return hello;
}
int& ReturnRef(void)
{
return hello;
}
int main(void)
{
const int& value = ReturnValue();
In the above the compiler creates a temporary in which it stores
a the value returned by ReturnValue. In effect something like:

int temp = ReturnValue();
int const &value = temp;

const int& ref = ReturnRef();

if ( &value == &ref )
{
std::cout << "They're the same!!" << std::endl;
}
else
{
std::cout << "They're different!!" << std::endl;
}

std::system("pa use");

}
, it prints "They're different". I'm curious as to why?!
I was thinking along these lines at first:

You can bind a temporary returned from a function to a reference.
This is true, but you conclusion doesen't follow.
Therefore, it's just the same as the function returning by reference,
except that it's const.

Binding temporaries to constant references *isn't* a result
of the way temoraries are created, it happens because the
standard says so, there is hence no "Therefore" .
As such, I expected the output to be "They're the same!!".
Any thoughts?

Logic applies to why the language is the way it is, but that
doesn't mean the language is (always) logical.

If you haven't got one already get a good book.
If you haven't got it already get a copy of the C++ Standard.

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Rob Williscroft]

JKop wrote in news:5u******** *********@news. indigo.ie in comp.lang.c++:

A function that returns a const reference.
A function that returns by value.
This is OK.
int Monkey(void)
{
int monkey = 72;

return monkey;
}

This is UB (it maybe diagnostic (i.e. warning) required).

const int& Ape(void)
{
int ape = 72;

return ape;
'ape' has now been destroyed, the returned reference, referes
to an object that no longer exists.

}
They're exactly the same, right? There shouldn't be any difference,
eg. an extra temporary made.

No.

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[JKop]

Rob Williscroft posted:

Therefore, it's just the same as the function returning by reference,
except that it's const.

Binding temporaries to constant references *isn't* a result
of the way temoraries are created, it happens because the
standard says so, there is hence no "Therefore" .

I'll make myself more clear:
int monkey(void);

const int& ape(void);
I wasn't talking about how you've to:

const int& primate = monkey;
-JKop

[JKop]

int monkey = ReturnIntValue( );

const int& monkey = ReturnIntValue( );
I once heard an argument that the binding-to-a-reference one is better
because it avoids an extra temporary. If this is so, why the hell doesn't
the following print "They're the same!!"?:

#include <iostream>

const int* g_p1;

const int* g_p2;
int Chocolate(void)
{
int monkey = 42;

g_p1 = &monkey;
return monkey;
}
int main(void)
{
const int& cream = Chocolate();

g_p2 = &cream;

if (g_p1 == g_p2)
{
std::cout << "They're the same!!";
}
{
std::cout << "They're different!!";
}

std::system("pa use");

}
-JKop

[Rob Williscroft]

JKop wrote in news:JK******** *********@news. indigo.ie in comp.lang.c++:

Rob Williscroft posted:

Therefore, it's just the same as the function returning by reference,
except that it's const.

Binding temporaries to constant references *isn't* a result
of the way temoraries are created, it happens because the
standard says so, there is hence no "Therefore" .

I'll make myself more clear:
int monkey(void);

const int& ape(void);
I wasn't talking about how you've to:

const int& primate = monkey;

That *isn't* clearer in any way.
Rob.
--
http://www.victim-prime.dsl.pipex.com/

[JKop]

Rob Williscroft posted:

JKop wrote in news:5u******** *********@news. indigo.ie in comp.lang.c++:

A function that returns a const reference.
A function that returns by value.

This is OK.

int Monkey(void)
{
int monkey = 72;

return monkey; }

This is UB (it maybe diagnostic (i.e. warning) required).

What does UB stand for?

While I'm asking, what does OP stand for?

const int& Ape(void)
{
int ape = 72;

return ape;

'ape' has now been destroyed, the returned reference, referes
to an object that no longer exists.

When you return by value, the object exists until the next ;. When you
return by reference, the object is destroy immediately. Is that what you're
saying? ie.

int ReturnIntValue( void);

const int& ReturnIntRef(vo id);

void TakesInt(const int);
int main(void)
{
TakesInt( ReturnIntValue( ) );

//Nothing wrong because the object exists until the next ;

TakesInt( ReturnIntRef() );

//This is undefined behaviour because the object was destroyed
//immediately

}
I don't know why I'm asking the following question, but still absolute
clarity would be nice:

const int ReturnValue(voi d);
int ReturnValue(voi d);
They're exactly the same, right? (Yes, I realize how stupid the question
sounds!)

-JKop

[JKop]

Rob Williscroft posted:

JKop wrote in news:JK******** *********@news. indigo.ie in comp.lang.c++:

Rob Williscroft posted:

Therefore, it's just the same as the function returning by reference,
except that it's const.
Binding temporaries to constant references *isn't* a result
of the way temoraries are created, it happens because the
standard says so, there is hence no "Therefore" .

I'll make myself more clear:
int monkey(void);

const int& ape(void);
I wasn't talking about how you've to:

const int& primate = monkey;

That *isn't* clearer in any way.
Rob.

Anyway, this has been addressed elsewhere in the thread.

END

-JKop